adambard/learnxinyminutes-docs
1
1
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-11-22 21:52:31 +03:00
Code Issues Projects Releases Wiki Activity

Merge pull request #1958 from MarioPerezEsteso/master

Browse Source 
Translate learn PHP and LaTeX to es-ES
This commit is contained in:
Adam Bard 2016-01-06 04:12:54 +08:00
commit 775c006c7b
2 changed files with 1037 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

212
es-es/latex-es.html.markdown Normal file
View File

@ -0,0 +1,212 @@
---
language: latex
contributors:
- ["Chaitanya Krishna Ande", "http://icymist.github.io"]
- ["Colton Kohnke", "http://github.com/voltnor"]
- ["Sricharan Chiruvolu", "http://sricharan.xyz"]
translators:
- ["Mario Pérez", "https://github.com/MarioPerezEsteso"]
filename: learn-latex-es.tex
---
```tex
% Todas las líneas comentadas comienzan con %
% No existen los comentarios multilínea
% LaTeX NO es un software de procesamiento de texto que cumple con
% "Lo que ves es lo que tienes" como MS Word u OpenOffice
% Todos los comandos de LaTeX comienzan con una contrabarra (\)
% Los documentos LaTeX comienzan definiendo el tipo de documento que se va a
% compilar. Algunos tipos de documentos son libros, informes, presentaciones,
% etc. Las opciones para el documento comienzan en los corchetes []. En este
% caso, se especifica que queremos utilizar una fuente de tamaño 12pt.
\documentclass[12pt]{article}
% A continuación, definimos los paquetes que utilizará el documento.
% Si quieres incluir gráficos, texto coloreado o código fuente de otro lenguaje,
% debes extender las funciones de LaTeX. Esto se consigue añadiendo paquetes.
% A continuación se incluirán los paquetes float y caption para figuras.
\usepackage{caption}
\usepackage{float}
% También podemos definir otras propiedades en el documento
\author{Chaitanya Krishna Ande, Colton Kohnke \& Sricharan Chiruvolu}
\date{\today}
\title{Learn LaTeX in Y Minutes!}
% Ahora estamos preparados para comenzar el documento
% Todo lo que se encuentre antes de esta línea se llama "El Preámbulo"
\begin{document}
% Si especificamos el autor, fecha y título, LaTeX creará una página como título
% por nosotros
\maketitle
% La mayoría de los artículos de investigación tienen un abstract. Es posible
% utilizar comandos predefinidos para ello.
% Esto debería aparecer en su orden lógico. Tras el título pero antes de las
% secciones principales del cuerpo.
% Este comando está disponible en los tipos de documentos article y report.
\begin{abstract}
Documentación de LaTex escrita en LaTex.
\end{abstract}
% Los comandos de sección son intuitivos.
% Todos los títulos de secciones son añadidos automáticamente a la tabla de contenidos.
\section{Introducción}
Hola, mi nombre es Mario Pérez y estoy traduciendo este documento para aprender LaTex.
\section{Otra sección}
Este es el texto de otra sección. Creo que necesitará una subsección.
\subsection{Esto es una subsección} % Las subsecciones también son fáciles.
Creo que necesitamos otra más.
\subsubsection{Pitágoras}
Mejor ahora.
\label{subsec:pitagoras}
% Utilizando el asterisco podemos decirle a LaTeX que no ponga los números de secciones y subsecciones.
% Esto también funciona con otros comandos de LaTeX.
\section*{Esto es una sección no numerada}
¡No todas las secciones tienen que estar numeradas!
\section{Algunas notas}
LaTeX es generalmente bastante bueno situando el texto donde debe ir. Si una lína \\ necesita \\ ser \\ rota \\ puedes poner \textbackslash\textbackslash en el código fuente. \\
\section{Listas}
Las listas son de las cosas más fáciles de crear en LaTeX. Necesito ir a comprar mañana, así que vamos a crear una lista de la compra.
\begin{enumerate} % Esto crea una lista numerada.
% \item crea un elemento
\item Ensalada.
\item 27 sandías.
\item Pescado.
% podemos incluso sobreescribir el número del ítem usando []
\item[cuántos?] Plátanos.
No es un ítem de la lista, pero sigue siendo parte de la enumeración.
\end{enumerate} % Todos los contextos deben tener un final.
\section{Matemáticas}
Uno de los usos principales de LaTeX es la producción de artículos académicos o técnicos. Normalmente relacionados con la ciencia y las matemáticas. Debido a esto, necesitamos poder añadir símbolos especiales a nuestro artículo.\\
En matemáticas hay muchos símbolos. Más de los que podemos encontrar en un teclado. Flechas o letras por nombrar un par.\\
Algunos símbolos juegan un papel fundamental en muchos artículos de investigación matemática. Así es como se establece que todo Y pertenece a X: $\forall$ x $\in$ X. \\
He necesitado añadir el signo $ antes de los símbolos. Esto se debe a que cuando escribimos, estamos en modo texto. Sin embargo, los símbolos solo pueden utilizarse en modo matemático, al cual se entra con el signo $.
% Lo opuesto también se cumple. Una variable también puede ser mostrada en modo matemático, al que también se puede entrar con \[\]
\[a^2 + b^2 = c^2 \]
Mi letra griega favorita es $\xi$. También me gustan $\beta$, $\gamma$ y $\sigma$.
Todavía no he encontrado una letra griega que LaTeX no conozca.
Los operadores son también una parte esencial de un documento matemático:
funciones trigonométricas ($\sin$, $\cos$, $\tan$), logaritmos y exponenciales ($\log$, $\exp$), límites ($\lim$), etc. tienen comandos predefinidos en LaTeX.
Vamos a escribir una ecuación para ver cómo se hace: \\
$\cos(2\theta) = \cos^{2}(\theta) - \sin^{2}(\theta)$
Las fracciones (numeradores-denominadores) pueden escribirse de la siguiente forma:
% 10 / 7
$^{10}/_{7}$
% Las fracciones relativamente complejas pueden escribirse como
% \frac{numerador}{denominador}
$\frac{n!}{k!(n - k)!}$ \\
También podemos insertar ecuaciones en un contexto de ecuación.
% Mostrar matemáticas en el contexto de ecuaciones
\begin{equation} % entra en modo matemático
c^2 = a^2 + b^2.
\label{eq:pitagoras} % para referencias
\end{equation} % Todos los contextos deben tener un final.
Podemos referenciar nuestra nueva ecuación.
Ecuación ~\ref{eq:pythagoras} también se conoce como el Teorema de Pitágoras, el cual también se encuentra en la sección ~\ref{subsec:pythagoras}. Muchas cosas pueden ser etiquetadas: figures, equations, sections, etc.
Los sumatorios e integrales son escritor son los comandos sum e int:
% Algunos compiladores de LaTeX se quejarán si hay líneas en blanco
% En un contexto de ecuación.
\begin{equation}
\sum_{i=0}^{5} f_{i}
\end{equation}
\begin{equation}
\int_{0}^{\infty} \mathrm{e}^{-x} \mathrm{d}x
\end{equation}
\section{Figuras}
Vamos a insertar una figura. Situarla puede ser algo complicado.
\begin{figure}[H] % H aquí establece la situación de la figura.
\centering % centra la figura en la página
% Inserta una figura escalada por 0.8 el ancho de la página.
%\includegraphics[width=0.8\linewidth]{right-triangle.png}
% La línea anterior ha sido comentada para poder compilar este archivo. Por favor, usa tu imaginación.
\caption{Triángulo con lados $a$, $b$, $c$}
\label{fig:right-triangle}
\end{figure}
\subsection{Tablas}
También podemos insertar tablas de la misma manera que las figuras.
\begin{table}[H]
\caption{Título para la tabla.}
% los argumentos en {} describen cómo cada fila va a ser representada.
\begin{tabular}{c|cc}
Número & Nombre & Apellido \\
\hline % una línea horizontal
1 & Biggus & Dickus \\
2 & Monty & Python
\end{tabular}
\end{table}
% \section{Hyperlinks} % En construcción
\section{Haciendo que LaTeX no compile algo (por ejemplo, código fuente)}
Digamos que queremos incluir código fuente dentro de nuestro documento LaTex. En ese caso, debemos indicarle a LaTeX que no trate de compilarlo y simplemente lo muestre en el documento. Esto lo realizamos en el contexto verbatim.
% Hay otros paquetes para esta misma tarea, pero verbatim es el más básico.
\begin{verbatim}
print("Hola Mundo!")
a%b; % Podemos usar los signos % en verbatim.
aleatorio = 4; # Número aleatorio
\end{verbatim}
\section{Compilación}
Ahora mismo te estarás preguntando cómo compilar este fabuloso documento y obtener un documento PDF.\\
Para obtener el documento final utilizando LaTeX hay que seguir los siguientes pasos:
\begin{enumerate}
\item Escribe el documento en texto plano.
\item Compila el código para producir un PDF.
Los pasos de compilación serán algo parecido a esto (en Linux): \\
\begin{verbatim}
$pdflatex learn-latex.tex learn-latex.pdf
\end{verbatim}
\end{enumerate}
Un gran número de editores LaTeX combinan ambos pasos para que sea más sencillo obtener el documento.
Escribe toda la información de formato en el paso 1 y con el paso 2 obtendrás el documento que has definido en el paso anterior.
\section{End}
Esto es todo por ahora.
% fin del documento
\end{document}
```
## Más información sobre LaTeX
* El wikilibro LaTeX: [https://es.wikibooks.org/wiki/Manual_de_LaTeX](https://es.wikibooks.org/wiki/Manual_de_LaTeX)
* Un tutorial real: [http://www.latex-tutorial.com/](http://www.latex-tutorial.com/)

825
es-es/php-es.html.markdown Normal file
View File

@ -0,0 +1,825 @@
---
language: PHP
contributors:
- ["Malcolm Fell", "http://emarref.net/"]
- ["Trismegiste", "https://github.com/Trismegiste"]
translators:
- ["Mario Pérez", "https://github.com/MarioPerezEsteso"]
lang: es-es
filename: learnphp-es.php
---
Este documento explica el funcionamiento de PHP 5+.
```php
<?php // El código PHP debe estar dentro de etiquetas <?php
// Si tu fichero php solo contiene código php, es una buena práctica
// omitir la etiqueta de cierre php para prevenir salidas acidentales.
// Dos barras comienzan un comentario de una línea.
# También lo hará una almohadilla, pero // es más común
/*
Escribir texto entre una barra-asterisco y asterisco-barra
crea un comentario multilínea.
*/
// Utiliza "echo" o "print" para imprimir por pantalla
print('Hola '); // Imprime "Hola " sin salto de línea
// () son opcionales para print y echo
echo "Mundo\n"; // Imprime "Mundo" con un salto de línea
// (todas las sentencias deben finalizar con un punto y coma)
// Cualquier cosa fuera de las etiquetas <?php se imprime automáticamente
?>
¡Hola Mundo de nuevo!
<?php
/************************************
* Tipos y variables
*/
// Las variables comienzan con el símbolo $.
// Una variable válida comienza con una letra o guión bajo,
// seguida de cualquier cantidad de letras, números o guiones bajos.
// Las variables booleanas no distinguen entre mayúsculas o minúsculas
$boolean = true; // o TRUE o True
$boolean = false; // o FALSE o False
// Enteros
$int1 = 12; // => 12
$int2 = -12; // => -12
$int3 = 012; // => 10 (un 0 al comienzo declara un número octal)
$int4 = 0x0F; // => 15 (un 0x al comienzo declara un hexadecimal)
// Floats (también conocidos como doubles)
$float = 1.234;
$float = 1.2e3;
$float = 7E-10;
// Eliminar variable
unset($int1);
// Operaciones aritméticas
$suma = 1 + 1; // 2
$diferencia = 2 - 1; // 1
$producto = 2 * 2; // 4
$cociente = 2 / 1; // 2
// Operaciones aritméticas de escritura rápida
$numero = 0;
$numero += 1; // Incrementa $numero en 1
echo $numero++; // Imprime 1 (incremento después la evaluación)
echo ++$numero; // Imprime 3 (incremento antes de la evaluación)
$numero /= $float; // Divide y asigna el cociente a $numero
// Las cadenas de caracteres deben declararse entre comillas simples
$sgl_quotes = '$String'; // => '$String'
// Evita utilizar comillas dobles excepto para embeber otras variables
$dbl_quotes = "This is a $sgl_quotes."; // => 'This is a $String.'
// Los caracteres especiales solo son válidos entre comillas dobles
$escaped = "Esto contiene \t un caracter tabulador.";
$unescaped = 'Esto solo contiene una barra y una t: \t';
// Rodea una variable entre corchetes si es necesario
$dinero = "Tengo $${numero} en el banco.";
// Desde PHP 5.3, los nowdocs pueden ser utilizados para multilíneas no interpoladas
$nowdoc = <<<'END'
Multi line
string
END;
// Heredocs interpola cadenas de caracteres
$heredoc = <<<END
Multi line
$sgl_quotes
END;
// La concatenación de cadenas de caracteres se realiza con .
echo 'Esta cadena de caracteres ' . 'está concatenada';
// Las cadenas de caracteres pueden ser pasadas como parámetros en un echo
echo 'Multiples', 'Parametros', 'Validos'; // Devuelve 'MultiplesParametrosValidos'
/********************************
* Constantes
*/
// Una constante se define utilizando define()
// y nunca puede ser cambiada en tiempo de ejecución
// un nombre válido para una constante debe comenzar con una letra o guión bajo,
// seguido por cualquier número de letras, números o guiones bajos.
define("FOO", "algo");
// el acceso a una constante se puede realizar llamando a la variable elegida sin un símbolo de $
echo FOO; // Devuelve 'algo'
echo 'Esto imprime '.FOO; // Devuelve 'Esto imprime algo'
/********************************
* Arrays
*/
// Todos los arrays en PHP son asociativos (hashmaps),
// Los arrays asociativos son conocidos como hashmaps en algunos lenguajes.
// Funciona con todas las versiones de php
$asociativo = array('Uno' => 1, 'Dos' => 2, 'Tres' => 3);
// PHP 5.4 introdujo una nueva sintaxis
$asociativo = ['Uno' => 1, 'Dos' => 2, 'Tres' => 3];
echo $asociativo['Uno']; // imprime 1
// Lista literales implícitamente asignados con claves enteras
$array = ['Uno', 'Dos', 'Tres'];
echo $array[0]; // => "Uno"
// Añadir un elemento al final de un array
$array[] = 'Cuatro';
// o
array_push($array, 'Cinco');
// Eliminar un elemento de un array
unset($array[3]);
/********************************
* Salidas por pantalla
*/
echo('¡Hola Mundo!');
// Imprime ¡Hola Mundo! en stdout.
// Stdout es la página web si se está ejecutando en un navegador.
print('!Hola Mundo!'); // Es lo mismo que echo
// No es necesario el paréntesis en echo y print
echo '¡Hola Mundo!';
print '¡Hola Mundo!';
$parrafo = 'parrafo';
echo 100; // Haz echo de escalares directamente
echo $parrafo; // o de variables
// Si las etiquetas cortas estás configuradas y tu versión de PHP es
// la 5.4.0 o superior, puede utilizar la sintaxis abreviada de echo
?>
<p><?= $parrafo?></p>
<?php
$x = 1;
$y = 2;
$x = $y; // $x ahora contiene el mismo valor que $y
$z = &$y;
// $z contiene ahora una referencia a $y. Un cambio en el valor de
// $z cambiará también el valor de $y, y viceversa.
// $x sin embargo, tendrá el valor original de $y
echo $x; // => 2
echo $z; // => 2
$y = 0;
echo $x; // => 2
echo $z; // => 0
// Dump muestra el tipo y valor de una variable en stdout
var_dump($z); // imprime int(0)
// Para mostrar el valor de una variable en un formato legible para humanos
print_r($array); // imprime: Array ( [0] => Uno [1] => Dos [2] => Tres )
/********************************
* Lógica
*/
$a = 0;
$b = '0';
$c = '1';
$d = '1';
// assert lanza una advertencia si su argumento no es verdadero
// Estas comparaciones siempre serán verdaderas, incluso si los tipos no son los mismos.
assert($a == $b); // igualdad
assert($c != $a); // desigualdad
assert($c <> $a); // desigualdad alternativa
assert($a < $c);
assert($c > $b);
assert($a <= $b);
assert($c >= $d);
// Los siguiente solo será verdadero si los valores coinciden y son del mismo tipo.
assert($c === $d);
assert($a !== $d);
assert(1 === '1');
assert(1 !== '1');
// Operador 'Spaceship' (desde PHP 7)
// Devuelve 0 si ambos valores son iguales
// Devuelve 1 si el valor de la izquierda es mayor
// Devuelve -1 si el valor de la derecha es mayor
$a = 100;
$b = 1000;
echo $a <=> $a; // 0 porque son iguales
echo $a <=> $b; // -1 porque $a < $b
echo $b <=> $a; // 1 porque $b > $a
// Las variables pueden ser convertidas entre tipos, dependiendo de su uso.
$entero = 1;
echo $entero + $entero; // => 2
$string = '1';
echo $string + $string; // => 2 (los strings son convertidos a enteros)
$string = 'uno';
echo $string + $string; // => 0
// Muestra un 0 porque el operador + no puede convertir la cadena de caracteres 'uno' a un número
// La conversión de tipos puede ser utilizada para tratar a una variable como otro tipo
$boolean = (boolean) 1; // => true
$cero = 0;
$boolean = (boolean) $cero; // => false
// También hay funciones dedicadas a la conversión de tipos
$entero = 5;
$string = strval($entero);
$var = null; // Valor nulo
/********************************
* Estructuras de control
*/
if (true) {
print 'He sido imprimido';
}
if (false) {
print 'Yo no';
} else {
print 'He sido imprimido';
}
if (false) {
print 'No se imprime';
} elseif(true) {
print 'Sí se imprime';
}
// operador ternario
print (false ? 'No se imprime' : 'Sí se imprime');
// atajo para el operador ternario desde PHP 5.3
// equivalente de "$x ? $x : 'Sí'""
$x = false;
print($x ?: 'Sí');
// operador 'no definido' desde php 7
$a = null;
$b = 'Imprime';
echo $a ?? 'a no está definido'; // imprime 'a no está definido'
echo $b ?? 'b no está definido'; // imprime 'Imprime'
$x = 0;
if ($x === '0') {
print 'No imprime';
} elseif($x == '1') {
print 'No imprime';
} else {
print 'Imprime';
}
// Esta sintaxis alternativa se utiliza para plantillas:
?>
<?php if ($x): ?>
Esto se muestra si la evaluación es verdadera.
<?php else: ?>
En otro caso, se muestra esto.
<?php endif; ?>
<?php
// Utiliza el switch para tener algo más de lógica.
switch ($x) {
case '0':
print 'Switch does type coercion';
break; // Debes incluir un break para no seguir con los casos 'Dos' y 'Tres'
case 'Dos':
case 'Tres':
// Hacer algo si la variables es 'Dos' o 'Tres'
break;
default:
// Hacer algo por defecto
}
// Los bucles While, do...while y for te serán familiares
$i = 0;
while ($i < 5) {
echo $i++;
}; // Imprime "01234"
echo "\n";
$i = 0;
do {
echo $i++;
} while ($i < 5); // Imprime "01234"
echo "\n";
for ($x = 0; $x < 10; $x++) {
echo $x;
} // Imprime "0123456789"
echo "\n";
$ruedas = ['bicicleta' => 2, 'coche' => 4];
// Los bucles foreach pueden iterar por arrays
foreach ($ruedas as $numero_ruedas) {
echo $numero_ruedas;
} // Imprime "24"
echo "\n";
// También se puede iterar sobre las claves, así como sobre los valores
foreach ($ruedas as $vehiculo => $numero_ruedas) {
echo "Un $vehiculo tiene $numero_ruedas ruedas";
}
echo "\n";
$i = 0;
while ($i < 5) {
if ($i === 3) {
break; // Sale fuera del bucle while
}
echo $i++;
} // Imprime "012"
for ($i = 0; $i < 5; $i++) {
if ($i === 3) {
continue; // Se salta esta iteración del bucle
}
echo $i;
} // Imprime "0124"
/********************************
* Funciones
*/
// Define una función con "function":
function mi_funcion () {
return 'Hola';
}
echo mi_funcion(); // => "Hola"
// Un nombre válido de función comienza con una letra o guión bajo, seguido de cualquier
// número de letras, números o guiones bajos.
function anadir ($x, $y = 1) { // $y es opcional y por defecto es 1
$resultado = $x + $y;
return $resultado;
}
echo anadir(4); // => 5
echo anadir(4, 2); // => 6
// $resultado no es accesible fuera de la función
// print $resultado; // Devuelve una advertencia.
// Desde PHP 5.3 se pueden declarar funciones anónimas
$inc = function ($x) {
return $x + 1;
};
echo $inc(2); // => 3
function foo ($x, $y, $z) {
echo "$x - $y - $z";
}
// Las funciones pueden devolver funciones
function bar ($x, $y) {
// Utiliza 'use' para meter variables de fuera de la función
return function ($z) use ($x, $y) {
foo($x, $y, $z);
};
}
$bar = bar('A', 'B');
$bar('C'); // Imprime "A - B - C"
// Puedes llamar a funciones utilizando cadenas de caracteres
$nombre_funcion = 'add';
echo $nombre_funcion(1, 2); // => 3
// Es útil para determinarl qué función ejecutar.
// O, utiliza call_user_func(callable $callback [, $parameter [, ... ]]);
// Puedes obtener todos los parámetros pasados a una función
function parametros() {
$numero_argumentos = func_num_args();
if ($numero_argumentos > 0) {
echo func_get_arg(0) . ' | ';
}
$args_array = func_get_args();
foreach ($args_array as $key => $arg) {
echo $key . ' - ' . $arg . ' | ';
}
}
parametros('Hola', 'Mundo'); // Hola | 0 - Hola | 1 - Mundo |
// Desde PHP 5.6 se puede obtener un número variable de argumentos
function variable($palabra, ...$lista) {
echo $palabra . " || ";
foreach ($lista as $item) {
echo $item . ' | ';
}
}
variable("Separa", "Hola", "Mundo") // Separa || Hola | Mundo |
/********************************
* Includes
*/
<?php
// Los ficheros PHP incluidos deben comenzar también con la etiqueta de <?php
include 'mi-fichero.php';
// El código de mi-fichero.php ya está disponible en el entorno actual.
// Si el fichero no puede ser incluido (por ejemplo porque no se ha encontrado),
// se muestra una advertencia.
include_once 'mi-fichero.php';
// Si el código del fichero mi-fichero.php ya ha sido incluido, ya no se
// incluirá de nuevo. Este previene errores por múltiples declaraciones.
require 'mi-fichero.php';
require_once 'mi-fichero.php';
// Es lo mismo que el include(), pero require() causará un error fatal si el archivo
// no ha podido ser incluido.
// Contenido de mi-include.php:
<?php
return 'Cualquier cosa.';
// acabar archivo
// Los include y require también pueden devolver un valor.
$valor = include 'mi-include.php';
// Los archivos son incluidos en función de la ruta data o, si ninguna ruta es
// especificada se utilizará la directiva de configuración de include_path. Si el
// fichero no se encuentra en el include_path, include comprobará la ruta del código
// que lo llama antes de fallar.
/* */
/********************************
* Clases
*/
// Las clases son definidas con la palabra clave class
class MiClase
{
const MI_CONSTANTE = 'valor'; // Una constante
static $staticVar = 'static';
// Las variables estáticas y su visibilidad
public static $publicStaticVar = 'publicStatic';
// Accesible solo dentro de su clase
private static $privateStaticVar = 'privateStatic';
// Accesible desde la clase y las subclases
protected static $protectedStaticVar = 'protectedStatic';
// Las propiedades deben declarar su visibilidad
public $propiedad = 'public';
public $instanceProp;
protected $prot = 'protected'; // Accesible desde la clase y las subclases
private $priv = 'private'; // Accesible solo desde la clase
// Crear un constructor con __construct
public function __construct($instanceProp) {
// Accede a las variables de la instancia con $this
$this->instanceProp = $instanceProp;
}
// Los métodos son declarados como funciones dentro de una clase
public function miMetodo()
{
print 'MiClase';
}
// la palabra clave final hará una función no sobreescribible
final function noMePuedesSobreEscribir()
{
}
/*
* Declarar propiedades de clase o métodos como estáticos los hace accesibles sin
* necesidad de instanciar la clase. Una propiedad declarada como estática no
* puede ser accedida mediante una instancia de la clase, pero sí mediante un
* método estático.
*/
public static function miMetodoEstatico()
{
print 'Soy estático';
}
}
// Las constantes de una clase siempre pueden ser accedidas estáticamente
echo MiClase::MI_CONSTANTE; // Muestra 'valor';
echo MiClase::$staticVar; // Muestra 'static';
MiClase::miMetodoEstatico(); // Muestra 'Soy estático';
// Instancia una clase usando new
$mi_clase = new MiClase('Una instancia');
// Los paréntesis son opcionales si no se pasa ningún argumento.
// Accede a los miembros de una clase utilizando ->
echo $mi_clase->propiedad; // => "public"
echo $mi_clase->instanceProp; // => "Una instancia"
$mi_clase->miMetodo(); // => "MiClase"
// Extender clases utilizando "extends"
class MiOtraClase extends MiClase
{
function imprimePropiedadProtegida()
{
echo $this->prot;
}
// Sobreescribe un método
function miMetodo()
{
parent::miMetodo();
print ' > MiOtraClase';
}
}
$mi_otra_clase = new MiOtraClase('Propiedad de instancia');
$mi_otra_clase->imprimePropiedadProtegida(); // => Imprime "protected"
$mi_otra_clase->miMetodo(); // Imprime "MiClase > MiOtraClase"
final class NoMePuedesExtender
{
}
// Puedes utilizar "métodos mágicos" para crear los getters y setters
class MiClaseMapeada
{
private $propiedad;
public function __get($key)
{
return $this->$key;
}
public function __set($key, $value)
{
$this->$key = $value;
}
}
$x = new MiClaseMapeada();
echo $x->propiedad; // Utilizará el método __get()
$x->propiedad = 'Algo'; // Utilizará el método __set()
// Las clases pueden ser abstractas (utilizando la palabra clave abstract) o
// implementando interfaces (utilizando la palabra clave implements).
// Una interfaz puede ser declarada con la palabra clave interface.
interface InterfazUno
{
public function hazAlgo();
}
interface InterfazDos
{
public function hazOtraCosa();
}
// las interfaces pueden ser extendidas
interface InterfazTres extends InterfazDos
{
public function hazCualquierOtraCosa();
}
abstract class MiClaseAbstracta implements InterfazUno
{
public $x = 'hazAlgo';
}
class MiOtraClase extends MiClaseAbstracta implements InterfazDos
{
public function hazAlgo()
{
echo $x;
}
public function hazOtraCosa()
{
echo 'hazOtraCosa';
}
}
// Las clases pueden implementar más de una interfaz
class CualquierOtraClase implements InterfazUno, InterfazDos
{
public function hazAlgo()
{
echo 'hazAlgo';
}
public function hazOtraCosa()
{
echo 'hazOtraCosa';
}
}
/********************************
* Traits
*/
// Los traits están disponibles desde PHP 5.4.0 y son declarados utilizando "trait"
trait MiTrait
{
public function miMetodoTrait()
{
print 'Tengo trait';
}
}
class MiClaseTrait
{
use MiTrait;
}
$cls = new MiClaseTrait();
$cls->miMetodoTrait(); // Imprime "Tengo trait"
/********************************
* Namespaces
*/
// Esta sección está separada porque una declaración de namespace debe
// ser la primera sentencia en un archivo. Vamos a suponer que no es el caso
<?php
// Por defecto, las clases existen en el namespace global y pueden ser llamadas
// explícitamente con una contrabarra.
$cls = new \MiClase();
// Estableder el namespace para un archivo
namespace Mi\Namespace;
class MiClase
{
}
// (de otro archivo)
$cls = new Mi\Namespace\MiClase;
// O de otro namespace.
namespace Mi\Otro\Namespace;
use Mi\Namespace\MiClase;
$cls = new MiClase();
// O se puede asignar un ales al namespace
namespace Mi\Otro\Namespace;
use Mi\Namespace as OtroNamespace;
$cls = new OtroNamespace\MiClase();
/**********************
* Late Static Binding
*
*/
class ClasePadre {
public static function quien() {
echo "Soy una " . __CLASS__ . "\n";
}
public static function test() {
// Auto referencia a la clase en la que el método está definido
self::quien();
// Referencia estáticamente a la clase donde el método ha sido llamado
static::quien();
}
}
ClasePadre::test();
/*
Soy una ClasePadre
Soy una ClasePadre
*/
class ClaseHija extends ClasePadre {
public static function quien() {
echo "Pero soy una " . __CLASS__ . "\n";
}
}
ClaseHija::test();
/*
Soy una ClasePadre
Pero soy una ClaseHija
*/
/**********************
* Manejo de errores
*
*/
// Una simple gestión de errores puede ser realizada con un bloque try catch
try {
// Haz algo
} catch (Exception $e) {
// Maneja la excepción
}
// Cuando se utilicen bloques try catch en un entorno con namespaces hay que
// usar lo siguiente
try {
// Haz algo
} catch (\Exception $e) {
// Maneja la excepción
}
// Excepciones personalizadas
class MiExcepcion extends Exception {}
try {
$condicion = true;
if ($condicion) {
throw new MiExcepcion('Ha pasado algo');
}
} catch (MiExcepcion $e) {
// Manejar la excepción
}
```
## Más información
Visita la [documentación oficial de PHP](http://www.php.net/manual/) para más referencias
y apoyo de la comunidad.
Si estás interesado en buenas prácticas, visita
[PHP The Right Way](http://www.phptherightway.com/).
Si vienes de un lenguaje con una buena gestión de paquetes, visita
[Composer](http://getcomposer.org/).
Para estándares comunes, visita el PHP Framework Interoperability Group
[PSR standards](https://github.com/php-fig/fig-standards).