• PHP significa PHP: Hypertext Preprocessor
  
• Los archivos PHP pueden contener texto, HTML, código JavaScript y código PHP
  
• El código PHP se ejecuta en el servidor y el resultado se devuelve al navegador en forma de HTML puro
  
• La extensión de archivo predeterminada para archivos PHP es ".php"

¿Qué puede hacer PHP?

• PHP puede generar contenido dinámico para páginas
  
• PHP puede crear, abrir, leer, escribir y cerrar archivos en el servidor
  
• PHP puede recopilar datos de formularios
  
• PHP puede enviar y recibir cookies
  
• PHP puede agregar, eliminar y modificar datos en su base de datos
  
• PHP puede restringir el acceso de los usuarios a algunas páginas de su sitio web
  
• PHP puede cifrar datos

Instalación

Si su servidor no es compatible con PHP, usted debe:

1. Instalar un servidor web
   
2. Instalar PHP
   
3. Instalar una base de datos, por ejemplo MySQL
   El sitio web oficial de PHP (PHP.net) tiene instrucciones de instalación de PHP:http://php.net/manual/en/install.php

Entorno de desarrollo integrado recomendado: WAMP:http://www.wampserver.com/

Sintaxis básica de PHP

Los scripts de PHP pueden colocarse en cualquier parte del documento.

Un script de PHP comienza con <?php y termina con ?>:

<!DOCTYPE html>
<html>
<body>

<h1>我的第一个 PHP 页面</h1>

<?php
echo "Hello World!";

// 这是一行注释

/*
这是
多行
注释
*/

?>

</body>
</html>

Cada línea de código en PHP debe terminar con un punto y coma

Dos instrucciones básicas para mostrar texto en el navegador: echo y print.

Variables en PHP

Las variables comienzan con el símbolo $, seguido del nombre de la variable

PHP no tiene un comando para declarar variables.

La variable se crea cuando usted le asigna un valor por primera vez:

PHP es un lenguaje de tipado débil
PHP convierte automáticamente la variable al tipo de dato correcto según su valor.

En lenguajes de programación de tipado fuerte, debemos declarar (definir) el tipo y el nombre de la variable antes de usarla.

Ámbito de las variables en PHP

PHP tiene cuatro ámbitos diferentes para las variables:

• local
  
• global
  
• static
  
• parameter

Ámbito local y global

Las variables definidas fuera de todas las funciones tienen ámbito global. Excepto dentro de las funciones, las variables globales pueden ser accedidas por cualquier parte del script. Para acceder a una variable global dentro de una función, se necesita utilizar la palabra clave global.

Las variables declaradas dentro de una función en PHP son variables locales, y solo se pueden acceder dentro de la función:

<?php
$x=5; // 全局变量

function myTest()
{
    $y=10; // 局部变量
    echo "<p>测试变量在函数内部:<p>";
    echo "变量 x 为: $x";
    echo "<br>";
    echo "变量 y 为: $y";
} 

myTest();

echo "<p>测试变量在函数外部:<p>";
echo "变量 x 为: $x";
echo "<br>";
echo "变量 y 为: $y";
?>

Para acceder dentro de una función a una variable global definida fuera de la función, debemos anteponer la palabra clave global a la variable dentro de la función:

<?php
$x=5;
$y=10;

function myTest()
{
    global $x,$y;
    $y=$x+$y;
}

myTest();
echo $y; // 输出 15
?>

PHP almacena todas las variables globales en un array llamado $GLOBALS[index]. index guarda el nombre de la variable. Este array se puede acceder dentro de las funciones y también se puede usar directamente para actualizar variables globales.

<?php
$x=5;
$y=10;

function myTest()
{
    $GLOBALS['y']=$GLOBALS['x']+$GLOBALS['y'];
} 

myTest();
echo $y;
?>

Ámbito Static

Cuando una función termina, todas sus variables normalmente se eliminan. Sin embargo, a veces desea que una variable local no se elimine; puede usarstaticla palabra clave

<?php

function myTest()
{
    static $x=0;
    echo $x;
    $x++;
}

myTest();
myTest();
myTest();

?>

Ámbito de los parámetros

Los parámetros son variables locales que reciben valores desde el código que llama a la función.

Los parámetros se declaran en la lista de parámetros, como parte de la declaración de la función:

<?php

function myTest($x)
{
    echo $x;
}

myTest(5);

?>

Sentencias echo y print en PHP

• echo - puede mostrar una o más cadenas de texto
  
• print - solo permite mostrar una cadena, y su valor de retorno siempre es 1

Consejo: echo es más rápido que print; echo no tiene valor de retorno, print tiene valor de retorno 1.
echo y print son estructuras de lenguaje; al usarlas se pueden omitir los paréntesis o también se pueden agregar: echo o echo(), print o print().

<?php
echo "<h2>PHP is fun!</h2>";
echo "Hello world!<br>";
echo "I'm about to learn PHP!<br>";
echo "This", " string", " was", " made", " with multiple parameters.";

print "<h2>PHP is fun!</h2>";
print "Hello world!<br>";
print "I'm about to learn PHP!";

?>

El siguiente ejemplo demuestra cómo usar el comando echo para mostrar variables y cadenas:

<?php
$txt1="Learn PHP";
$txt2="example.com";
$cars=array("Volvo","BMW","Toyota");

echo $txt1;
echo "<br>";
echo "Study PHP at $txt2"; //php 双引号内部可包含变量
echo "My car is a {$cars[0]}"; //用大括号 显式的指定这是变量

$txt1="Learn PHP";
$txt2="example.com";
$cars=array("Volvo","BMW","Toyota");

print $txt1;
print "<br>";
print "Study PHP at $txt2";
print "My car is a {$cars[0]}";

?>

Tipos de datos en PHP5

String (cadena), Integer (entero), Float (flotante), Boolean (booleano), Array (arreglo), Object (objeto), NULL (nulo).

Cadenas
Puede colocar cualquier texto entre comillas simples y dobles:

<?php 
$x = "Hello world!";
echo $x;
echo "<br>"; 
$x = 'Hello world!'; //单引号 包括字符串字面量 双引号包含的字符串 可包含变量
echo $x;
?>

Enteros
En el siguiente ejemplo probaremos diferentes números. PHPvar_dump()La función devuelve el tipo de dato y el valor de la variable:

?php 
$x = 5985;
var_dump($x);
echo "<br>"; 
$x = -345; // 负数 
var_dump($x);
echo "<br>"; 
$x = 0x8C; // 十六进制数
var_dump($x);
echo "<br>";
$x = 047; // 八进制数
var_dump($x);
?>

Flotantes

<?php 
$x = 10.365;
var_dump($x);
echo "<br>"; 
$x = 2.4e3;
var_dump($x);
echo "<br>"; 
$x = 8E-5;
var_dump($x);
?>

Booleanos

El tipo booleano puede ser TRUE o FALSE.

Arrays

Un array puede almacenar múltiples valores en una sola variable

<?php 
$cars=array("Volvo","BMW","Toyota");
var_dump($cars);
?>

Objetos

En PHP, los objetos deben ser declarados.

Primero, debe declarar un objeto de clase usando la palabra clave class. Una clase es una estructura que puede contener propiedades y métodos.
Luego definimos el tipo de dato en la clase y después lo usamos en la clase instanciada:

<?php
class Car
{
    var $color;
    function Car($color="green") {
      $this->color = $color;
    }
    function what_color() {
      return $this->color;
    }
}

function print_vars($obj) {
   foreach (get_object_vars($obj) as $prop => $val) {
     echo "\t$prop = $val\n";
   }
}

// instantiate one object
$herbie = new Car("white");

// show herbie properties
echo "\herbie: Properties\n";
print_vars($herbie);

?>  

Valor NULL
El valor NULL indica que la variable no tiene valor. NULL es un valor cuyo tipo de dato es NULL.

<?php
$x="Hello world!";
$x=null;
var_dump($x);
?>

Constantes

Una constante es un identificador de un valor simple. Ese valor no puede cambiar durante el script. (El nombre de una constante no necesita el prefijo $).

Nota: las constantes se pueden usar en todo el script.

Para definir una constante se usa la función define(), cuya sintaxis es la siguiente:

define(string constant_name, mixed value, case_sensitive = true)
Esta función tiene tres parámetros:

• constant_name: parámetro obligatorio, el nombre de la constante, es decir, el identificador.
  
• value: parámetro obligatorio, el valor de la constante.
  
• case_sensitive: parámetro opcional, especifica si distingue entre mayúsculas y minúsculas; si se establece en true, no distingue.

En el siguiente ejemplo creamos una constante que distingue entre mayúsculas y minúsculas, con el valor "Welcome to example.com!":

<?php
define("GREETING", "Welcome to example.com!");
echo GREETING;
?>

Funciones de cadenas y concatenación de cadenas

<?php
$txt1="Hello world!";
$txt2="What a nice day!";
echo $txt1 . " " . $txt2; // 字符串连接运算符 .

echo strlen("Hello world!"); //获取字符串长度
echo strpos("Hello world!","world"); //获取子串位置
//字符串中第一个字符的位置是 0
?>

Operadores

<?php
//其他运算符略..
//逻辑运算符 ! && || and or xor
//数组运算符 合并: + 比较：== != === !==
$x = array("a" => "red", "b" => "green"); 
$y = array("c" => "blue", "d" => "yellow"); 
$z = $x + $y; // $x 和 $y 数组合并
var_dump($z);
var_dump($x == $y);
var_dump($x === $y);
var_dump($x != $y);
var_dump($x <> $y);
var_dump($x !== $y);
?>

Sentencias de control de flujo (igual que en JS)

<?php

$t=date("H");
if ($t<"20")
{
    echo "Have a good day!";
}



$t=date("H");
if ($t<"20")
{
    echo "Have a good day!";
}
else
{
    echo "Have a good night!";
}

$t=date("H");
if ($t<"10")
{
    echo "Have a good morning!";
}
else if ($t<"20")
{
    echo "Have a good day!";
}
else
{
    echo "Have a good night!";
}

$favcolor="red";
switch ($favcolor)
{
    case "red":
    echo "Your favorite color is red!";
    break;
    case "blue":
    echo "Your favorite color is blue!";
    break;
    case "green":
    echo "Your favorite color is green!";
    break;
    default:
    echo "Your favorite color is neither red, blue, or green!";
}

//循环
$i=1;
while($i<=5)
{
    echo "The number is " . $i . "<br>";
    $i++;
}


$i=1;
do
{
    $i++;
    echo "The number is " . $i . "<br>";
}
while ($i<=5);

for ($i=1; $i<=5; $i++)
{
    echo "The number is " . $i . "<br>";
}


$x=array("one","two","three");
foreach ($x as $value)
{
    echo $value . "<br>";
}

?>

Arrays

<?php
$cars=array("Volvo","BMW","Toyota"); //数组定义 数值数组
echo "I like " . $cars[0] . ", " . $cars[1] . " and " . $cars[2] . "."; //访问数组元素

//数组长度count()
$cars=array("Volvo","BMW","Toyota");
echo count($cars); //count() 函数用于返回数组的长度

//遍历数值数组
$cars=array("Volvo","BMW","Toyota");
$arrlength=count($cars);

for($x=0;$x<$arrlength;$x++)
{
    echo $cars[$x];
    echo "<br>";
}

$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");//定义关联数组
echo "Peter is " . $age['Peter'] . " years old.";

//遍历关联数组
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
foreach($age as $x=>$x_value)
{
    echo "Key=" . $x . ", Value=" . $x_value;
    echo "<br>";
}
?>

Ordenamiento de arrays

PHP - Funciones de ordenamiento de arrays

• sort() - Ordena un array en orden ascendente
  
• rsort() - Ordena un array en orden descendente
  
• asort() - Ordena un array asociativo en orden ascendente según sus valores
  
• ksort() - Ordena un array asociativo en orden ascendente según sus claves
  
• arsort() - Ordena un array asociativo en orden descendente según sus valores
  
• krsort() - Ordena un array asociativo en orden descendente según sus claves

//sort()
$cars=array("Volvo","BMW","Toyota");
sort($cars);

$clength=count($cars);
for($x=0;$x<$clength;$x++)
{
    echo $cars[$x];
    echo "<br>";
}

//rsort()   
$cars=array("Volvo","BMW","Toyota");
rsort($cars);   

//asort() arsort() 关联数组排序 value
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
asort($age);
arsort($age);

//ksort() krsort() 关联数组排序 key
$age=array("Peter"=>"35","Ben"=>"37","Joe"=>"43");
ksort($age);
krsort($age);
?>

Variables superglobales

PHP tiene varias variables superglobales predefinidas, lo que significa que están disponibles en todos los ámbitos de un script.

• $GLOBALS
  
• $_SERVER
  
• $_REQUEST
  
• $_POST
  
• $_GET
  
• $_COOKIE
  
• $_FILES
  
• $_ENV
  
• $_SESSION

$GLOBAL es un array global combinado que contiene todas las variables. El nombre de la variable es la clave del array.

<?php 
$x = 75; 
$y = 25;
 
function addition() 
{ 
    $GLOBALS['z'] = $GLOBALS['x'] + $GLOBALS['y']; 
}
 
addition(); 
echo $z; 
?>

$_SERVER es un array que contiene información como cabeceras (header), rutas (path) y ubicaciones de scripts (script locations), entre otros. Los elementos de este array son creados por el servidor web. No se garantiza que todos los servidores proporcionen todos los elementos;

<?php 
echo $_SERVER['PHP_SELF']; // /try/demo_source/demo_global_server.php
echo "<br>";
echo $_SERVER['SERVER_NAME']; // example.com
echo "<br>";
echo $_SERVER['HTTP_HOST']; // www.example.com
echo "<br>";
echo $_SERVER['HTTP_REFERER']; //来由
echo "<br>";
echo $_SERVER['HTTP_USER_AGENT']; //浏览器
echo "<br>";
echo $_SERVER['SCRIPT_NAME']; // /try/demo_source/demo_global_server.php

//另外$_SERVER对象还包括 SERVER_ADDR, SERVER_PROTOCOL ,REQUEST_METHOD..等属性

?>

$_REQUEST se usa para recopilar los datos enviados por un formulario HTML.

<html>
<body>

<form method="post" action="<?php echo $_SERVER['PHP_SELF'];?>">
Name: <input type="text" name="fname">
<input type="submit">
</form>

<?php 
$name = $_REQUEST['fname']; 
echo $name; 
?>

</body>
</html>

$_POST se usa ampliamente para recopilar datos de formularios, especificando en la etiqueta HTML form el atributo: "method="post""

<html>
<body>
<!--页面post给自己-->
<form method="post" action="<?php echo $_SERVER['PHP_SELF'];?>">
Name: <input type="text" name="fname">
<input type="submit">
</form>

<?php 
$name = $_POST['fname']; 
echo $name; 
?>

</body>
</html>

$_GET también se usa ampliamente para recopilar datos de formularios, especificando en la etiqueta HTML form el atributo: "method="get"".

$_GET también puede recopilar los datos enviados en la URL.

<html>
<body>

<a href="test_get.php.html">Test $GET</a>

</body>
</html>

//test_get.php

<html>
<body>

<?php 
echo "Study " . $_GET['subject'] . " at " . $_GET['web'];
?>

</body>
</html>

Funciones en PHP

El verdadero poder de PHP proviene de sus funciones.

En PHP, se ofrecen más de 1000 funciones integradas.

<html>
<body>

<?php
function writeName()
{
    echo "Kai Jim Refsnes";
}

echo "My name is ";
writeName();

//函数传参
function writeName($fname,$punctuation)
{
    echo $fname . " Refsnes" . $punctuation . "<br>";
}

echo "My name is ";
writeName("Kai Jim",".");
echo "My sister's name is ";

//函数返回值
function add($x,$y)
{
    $total=$x+$y;
    return $total;
}

echo "1 + 16 = " . add(1,16);

?>

</body>
</html>

Variables mágicas

Hay ocho constantes mágicas cuyos valores cambian según su posición en el código.

• _LINE__
  El número de línea actual del archivo.
  
• FILE
  La ruta completa y el nombre del archivo. Si se usa en un archivo incluido, se devuelve el nombre del archivo incluido.
  
• DIR
  El directorio donde se encuentra el archivo. Si se usa en un archivo incluido, se devuelve el directorio donde se encuentra el archivo incluido.
  
• FUNCTION
  Nombre de la función (nuevo en PHP 4.3.0). Desde PHP 5, esta constante devuelve el nombre de la función tal como fue definida (distingue mayúsculas y minúsculas). En PHP 4, este valor siempre estaba en minúsculas.

<?php
function test() {
    echo  '函数名为：' . __FUNCTION__ ;
}
test();
?>

• CLASSNombre de la clase (nuevo en PHP 4.3.0). Desde PHP 5, esta constante devuelve el nombre de la clase tal como fue definida (distingue mayúsculas y minúsculas).

En PHP 4, este valor siempre estaba en minúsculas. El nombre de la clase incluye el espacio de nombres donde fue declarada (por ejemplo, Foo\Bar). Tenga en cuenta que desde PHP 5.4CLASStambién funciona con traits. Cuando se usa en un método de un trait,CLASSes el nombre de la clase que invoca el método del trait.

<?php
class test {
    function _print() {
        echo '类名为：'  . __CLASS__ . "<br>";
        echo  '函数名为：' . __FUNCTION__ ;
    }
}
$t = new test();
$t->_print();
?>

• TRAITNombre del trait (nuevo en PHP 5.4.0). Desde PHP 5.4.0, PHP implementó un método de reutilización de código llamado traits.

El nombre del trait incluye el espacio de nombres donde fue declarado (por ejemplo, Foo\Bar).

Los miembros heredados de la clase base son reemplazados por el método MyHelloWorld del trait SayWorld insertado. Su comportamiento es el mismo que el método definido en la clase MyHelloWorld. El orden de prioridad es que los métodos de la clase actual reemplazan a los métodos del trait, y los métodos del trait reemplazan a los métodos de la clase base.

<?php
class Base {
    public function sayHello() {
        echo 'Hello ';
    }
}

trait SayWorld {
    public function sayHello() {
        parent::sayHello();
        echo 'World!';
    }
}

class MyHelloWorld extends Base {
    use SayWorld;
}

$o = new MyHelloWorld();
$o->sayHello();
?>

• METHODNombre del método de la clase (nuevo en PHP 5.0.0). Devuelve el nombre del método tal como fue definido (distingue mayúsculas y minúsculas).

<?php
function test() {
    echo  '函数名为：' . __METHOD__ ;
}
test();
?>

• NAMESPACENombre del espacio de nombres actual (distingue mayúsculas y minúsculas). Esta constante se define en tiempo de compilación (nuevo en PHP 5.3.0).

<?php
namespace MyProject;

echo '命名空间为："', __NAMESPACE__, '"'; // 输出 "MyProject"
?>

Espacios de nombres

Los espacios de nombres (namespace) en PHP se introdujeron en PHP 5.3. Si has aprendido C# y Java, los espacios de nombres no son nada nuevo. Sin embargo, en PHP tienen una importancia bastante significativa.

Los espacios de nombres en PHP pueden resolver los siguientes dos tipos de problemas:

• Conflictos de nombres entre el código del usuario y las clases/funciones/constantes internas de PHP.
  
• Crear nombres con alias (o más cortos) para mejorar la legibilidad del código fuente.

De forma predeterminada, todos los nombres de constantes, clases y funciones se colocan en el espacio global, igual que antes de que PHP admitiera espacios de nombres.
Si un archivo contiene un espacio de nombres, debe declarar el espacio de nombres antes que cualquier otro código.

< ?php  
// 定义代码在 'MyProject' 命名空间中  
namespace MyProject;  
 
// ... 代码 ...  

//也可以在同一个文件中定义不同的命名空间代码
namespace MyProject1;  
// MyProject1 命名空间中的PHP代码  
 
namespace MyProject2;  
// MyProject2 命名空间中的PHP代码    
 
// 另一种语法
namespace MyProject3 {  
 // MyProject3 命名空间中的PHP代码    
}  

?>

El único código legal antes de declarar un espacio de nombres es la sentencia declare utilizada para definir la codificación del archivo fuente. Ningún código que no sea PHP, incluidos los espacios en blanco, puede aparecer antes de la declaración del espacio de nombres.

<?php
declare(encoding='UTF-8'); //定义多个命名空间和不包含在命名空间中的代码
namespace MyProject {
    const CONNECT_OK = 1;
    class Connection { /* ... */ }
    function connect() { /* ... */  }
}

namespace { // 全局代码
    session_start();
    $a = MyProject\connect();
    echo MyProject\Connection::start();
}
?>

El siguiente código provocará un error de sintaxis:

<html>
<?php
namespace MyProject; // 命名空间前出现了“<html>” 会致命错误 -　命名空间必须是程序脚本的第一条语句
?>

Subespacios de nombres

<?php
namespace MyProject\Sub\Level;  //声明分层次的单个命名空间
//创建了常量 MyProject\Sub\Level\CONNECT_OK，
//类 MyProject\Sub\Level\Connection 
//和函数 MyProject\Sub\Level\Connect.

const CONNECT_OK = 1;
class Connection { /* ... */ }
function Connect() { /* ... */  }

?>

Uso de espacios de nombres
Los nombres de clase en los espacios de nombres de PHP se pueden referenciar de tres formas:

1. Nombre no calificado, o nombre de clase sin prefijo, por ejemplo $a=new foo(); o foo::staticmethod();. Si el espacio de nombres actual es currentnamespace, foo se resolverá como currentnamespace\foo. Si el código que usa foo es global, es decir, código que no está en ningún espacio de nombres, foo se resolverá como foo. Advertencia: si una función o constante en el espacio de nombres no está definida, el nombre de función o constante no calificado se resolverá como el nombre de función o constante global.~~Referencia sin prefijo de espacio de nombres: por defecto busca en el espacio de nombres actual y luego en el espacio de nombres global.

2. Nombre calificado, o nombre con prefijo, por ejemplo $a = new subnamespace\foo(); o subnamespace\foo::staticmethod();. Si el espacio de nombres actual es currentnamespace, foo se resolverá como currentnamespace\subnamespace\foo. Si el código que usa foo es global, es decir, código que no está en ningún espacio de nombres, foo se resolverá como subnamespace\foo.~~Referencia con prefijo de espacio de nombres relativo (similar a una ruta relativa), agrega automáticamente al inicio el espacio de nombres donde se encuentra el código que realiza la llamada.

3. Nombre totalmente calificado, o nombre que incluye el operador de prefijo global, por ejemplo, $a = new \currentnamespace\foo(); o \currentnamespace\foo::staticmethod();. En este caso, foo siempre se resuelve como el nombre literal (literal name) del código: currentnamespace\foo.~~Referencia con prefijo de espacio de nombres absoluto (similar a una ruta absoluta). La ruta de referencia ya está definida, no necesita búsqueda.

file1.php

<?php
namespace Foo\Bar\subnamespace; 

const FOO = 1;
function foo() {}
class foo
{
    static function staticmethod() {}
}
?>

file2.php

<?php
namespace Foo\Bar;
include 'file1.php';

const FOO = 2;
function foo() {}
class foo
{
    static function staticmethod() {}
}

/* 非限定名称 */
foo(); // 解析为函数 Foo\Bar\foo
foo::staticmethod(); // 解析为类 Foo\Bar\foo的静态方法staticmethod.
echo FOO; // resolves to constant Foo\Bar\FOO

/* 限定名称 */
subnamespace\foo(); // 解析为函数 Foo\Bar\subnamespace\foo
subnamespace\foo::staticmethod(); // 解析为类 Foo\Bar\subnamespace\foo,
                                  // 以及类的方法 staticmethod
echo subnamespace\FOO; // 解析为常量 Foo\Bar\subnamespace\FOO
                                  
/* 完全限定名称 */
\Foo\Bar\foo(); // 解析为函数 Foo\Bar\foo
\Foo\Bar\foo::staticmethod(); // 解析为类 Foo\Bar\foo, 以及类的方法 staticmethod
echo \Foo\Bar\FOO; // 解析为常量 Foo\Bar\FOO
?>

Acceder a clases, funciones y constantes globales dentro de un espacio de nombres:

<?php
namespace Foo;

function strlen() {}
const INI_ALL = 3;
class Exception {}

$a = \strlen('hi'); // 调用全局函数strlen
$b = \INI_ALL; // 访问全局常量 INI_ALL
$c = new \Exception('error'); // 实例化全局类 Exception
?>

Espacios de nombres y características dinámicas del lenguaje

La implementación de los espacios de nombres en PHP está influenciada por las características dinámicas del propio lenguaje. Por lo tanto, para convertir el siguiente código a un espacio de nombres, se deben acceder dinámicamente a los elementos.

//example.php

<?php
class classname
{
    function __construct()
    {
        echo __METHOD__,"\n";
    }
}
function funcname()
{
    echo __FUNCTION__,"\n";
}
const constname = "global";

$a = 'classname';
$obj = new $a; // prints classname::__construct
$b = 'funcname';
$b(); // prints funcname
echo constant('constname'), "\n"; // prints global
?>

<?php
namespace namespacename;
class classname
{
    function __construct()
    {
        echo __METHOD__,"\n";
    }
}
function funcname()
{
    echo __FUNCTION__,"\n";
}
const constname = "namespaced";

include 'example1.php';//全局命名空间和某个命名空间有相同类 函数 和 常量 分别区别访问

$a = 'classname';
$obj = new $a; // prints classname::__construct
$b = 'funcname';
$b(); // prints funcname
echo constant('constname'), "\n"; // prints global

/* note that if using double quotes, "\\namespacename\\classname" must be used */
$a = '\namespacename\classname';
$obj = new $a; // prints namespacename\classname::__construct
$a = 'namespacename\classname';
$obj = new $a; // also prints namespacename\classname::__construct
$b = 'namespacename\funcname';
$b(); // prints namespacename\funcname
$b = '\namespacename\funcname';
$b(); // also prints namespacename\funcname
echo constant('\namespacename\constname'), "\n"; // prints namespaced
echo constant('namespacename\constname'), "\n"; // also prints namespaced
?>

La palabra clave namespace y la constante __NAMESPACE__

<?php
namespace MyProject;

echo '"', __NAMESPACE__, '"'; // 输出 "MyProject"
?>

<?php

echo '"', __NAMESPACE__, '"'; // 输出 ""
?>

Crear nombres dinámicamente usando __NAMESPACE__

<?php
namespace MyProject;

function get($classname)
{
    $a = __NAMESPACE__ . '\\' . $classname;
    return new $a;
}
?>

La palabra clave namespace se puede utilizar para acceder explícitamente a elementos del espacio de nombres actual o de un subespacio de nombres. Es equivalente al operador self en las clases.

<?php
namespace MyProject;

use blah\blah as mine; // see "Using namespaces: importing/aliasing"

blah\mine(); // calls function blah\blah\mine()
namespace\blah\mine(); // calls function MyProject\blah\mine()

namespace\func(); // calls function MyProject\func()
namespace\sub\func(); // calls function MyProject\sub\func()
namespace\cname::method(); // calls static method "method" of class MyProject\cname
$a = new namespace\sub\cname(); // instantiates object of class MyProject\sub\cname
$b = namespace\CONSTANT; // assigns value of constant MyProject\CONSTANT to $b
?>

En PHP, los alias se implementan mediante el operador use. A continuación se muestra un ejemplo que utiliza las tres formas posibles de importación:

1. Importar/usar alias con el operador use

<?php
namespace foo;
use My\Full\Classname as Another;

// 下面的例子与 use My\Full\NSname as NSname 相同
use My\Full\NSname;

// 导入一个全局类
use \ArrayObject;

$obj = new namespace\Another; // 实例化 foo\Another 对象
$obj = new Another; // 实例化 My\Full\Classname　对象
NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func
$a = new ArrayObject(array(1)); // 实例化 ArrayObject 对象
// 如果不使用 "use \ArrayObject" ，则实例化一个 foo\ArrayObject 对象
?>

1. Múltiples sentencias use en una sola línea

<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // 实例化 My\Full\Classname 对象
NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func
?>
<p>导入操作是在编译执行的，但动态的类名称、函数名称或常量名称则不是。</p>
<ol>
<li>导入和动态名称</li>
</ol>
<pre>
<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // 实例化一个 My\Full\Classname 对象
$a = 'Another';
$obj = new $a;      // 实际化一个 Another 对象
?>

1. Importación y nombres dinámicos

<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // 实例化一个 My\Full\Classname 对象
$a = 'Another';
$obj = new $a;      // 实际化一个 Another 对象
?>

Además, la operación de importación solo afecta a los nombres no calificados y calificados. Los nombres totalmente calificados, al ser deterministas, no se ven afectados por la importación.

1. Importación y nombres totalmente calificados

<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // instantiates object of class My\Full\Classname
$obj = new \Another; // instantiates object of class Another
$obj = new Another\thing; // instantiates object of class My\Full\Classname\thing
$obj = new \Another\thing; // instantiates object of class Another\thing
?>

Usar espacios de nombres: funciones/constantes globales de respaldo

Dentro de un espacio de nombres, cuando PHP encuentra un nombre de clase, función o constante no calificado, utiliza diferentes estrategias de prioridad para resolver dicho nombre.

• Los nombres de clase siempre se resuelven al nombre en el espacio de nombres actual (si no se encuentra, se produce un error).Por lo tanto, al acceder a nombres de clase internos del sistema o que no están en un espacio de nombres, se debe utilizar el nombre totalmente calificado.
  
• En cuanto a funciones y constantes, si la función o constante no existe en el espacio de nombres actual, PHP recurre a la función o constante del espacio global.

<?php
namespace A\B\C;
class Exception extends \Exception {}

$a = new Exception('hi'); // $a 是类 A\B\C\Exception 的一个对象
$b = new \Exception('hi'); // $b 是类 Exception 的一个对象

$c = new ArrayObject; // 致命错误, 找不到 A\B\C\ArrayObject 类
?>

Espacio global
Si no se define ningún espacio de nombres, todas las definiciones de clases y funciones se encuentran en el espacio global, igual que antes de que PHP introdujera el concepto de espacios de nombres. Anteponer el prefijo \ a un nombre indica que dicho nombre pertenece al espacio global, incluso si ese nombre se encuentra en otro espacio de nombres.

<?php
namespace A\B\C;

/* 这个函数是 A\B\C\fopen */
function fopen() { 
     /* ... */
     $f = \fopen(...); // 调用全局的fopen函数
     return $f;
} 
?>

Orden de los espacios de nombres (omitido)...

Manejo de archivos en PHP

Abrir archivos

$file = fopen($fname, mode) //Nombre del archivo, modo de apertura

• r Solo lectura. Comienza al inicio del archivo.
  
• r+ Lectura/escritura. Comienza al inicio del archivo.
  
• w Solo escritura. Abre y vacía el contenido del archivo; si el archivo no existe, crea un archivo nuevo.
  
• w+ Lectura/escritura. Abre y vacía el contenido del archivo; si el archivo no existe, crea un archivo nuevo.
  
• a Añadir (append). Abre y escribe al final del archivo; si el archivo no existe, crea un archivo nuevo.
  
• a+ Lectura/adicional. Mantiene el contenido del archivo escribiendo al final del mismo.
  
• x Solo escritura. Crea un archivo nuevo. Si el archivo ya existe, devuelve FALSE y un error.
  
• x+ Lectura/escritura. Crea un archivo nuevo. Si el archivo ya existe, devuelve FALSE y un error.

Nota: si la función fopen() no puede abrir el archivo especificado, devuelve 0 (false).

<?php
//打开文件
$file = fopen("welcome.txt", "r") or exit("Unable to open file!");
//Output a line of the file until the end is reached

//是否到达文件末尾 
while(!feof($file))
{
    echo fgets($file). "<br>"; //逐行读取文件
    //echo fgetc($file); //逐字符读取

}
//关闭文件
fclose($file);
?>

Funciones del sistema de archivos (Filesystem)

• basename() Devuelve la parte del nombre de archivo de una ruta.
  
• chgrp() Cambia el grupo del archivo.
  
• chmod() Cambia el modo del archivo.
  
• chown() Cambia el propietario del archivo.
  
• clearstatcache() Limpia la caché de estado de los archivos.
  
• copy() Copia un archivo.
  
• delete() Ver unlink() o unset()
  
• dirname() Devuelve la parte del directorio de una ruta.
  
• disk_free_space() Devuelve el espacio libre disponible de un directorio.
  
• disk_total_space() Devuelve la capacidad total del disco de un directorio.
  
• diskfreespace() Alias de disk_free_space().
  
• fclose() Cierra un archivo abierto.
  
• feof() Comprueba si el puntero del archivo ha llegado al final del archivo.
  
• fflush() Vacía la salida almacenada en el búfer hacia el archivo abierto.
  
• fgetc() Devuelve un carácter de un archivo abierto.
  
• fgetcsv() Analiza una línea de un archivo abierto y verifica los campos CSV.
  
• fgets() Devuelve una línea de un archivo abierto.
  
• fgetss() Devuelve una línea de un archivo abierto y filtra las etiquetas HTML y PHP.
  
• file() Lee un archivo en un array.
  
• file_exists() Comprueba si existe un archivo o directorio.
  
• file_get_contents() Lee un archivo en una cadena. ~~Obtener el contenido del archivo
  
• file_put_contents() Escribe una cadena en un archivo. ~~Escribir contenido en un archivo
  
• fileatime() Devuelve la hora del último acceso al archivo.
  
• filectime() Devuelve la hora de la última modificación del archivo.
  
• filegroup() Devuelve el ID de grupo del archivo.
  
• fileinode() Devuelve el número de inodo del archivo.
  
• filemtime() Devuelve la hora de la última modificación del contenido del archivo.
  
• fileowner() Devuelve el ID de usuario (propietario) del archivo.
  
• fileperms() Devuelve los permisos del archivo.
  
• filesize() Devuelve el tamaño del archivo.
  
• filetype() Devuelve el tipo de archivo.
  
• flock() Bloquea o libera un archivo.
  
• fnmatch() Compara un nombre de archivo o cadena con un patrón especificado.
  
• fopen() Abre un archivo o URL.
  
• fpassthru() Lee datos de un archivo abierto hasta el final (EOF) y escribe el resultado en el búfer de salida.
  
• fputcsv() Formatea una línea como CSV y la escribe en un archivo abierto.
  
• fputs() Alias de fwrite().
  
• fread() Lee un archivo abierto.
  
• fscanf() Analiza la entrada según un formato especificado.
  
• fseek() Se posiciona en un archivo abierto.
  
• fstat() Devuelve información sobre un archivo abierto.
  
• ftell() Devuelve la posición actual en un archivo abierto.
  
• ftruncate() Trunca un archivo abierto a la longitud especificada.
  
• fwrite() Escribe en un archivo abierto.
  
• glob() Devuelve una matriz de nombres de archivo/directorios que coinciden con el patrón especificado.
  
• is_dir() Comprueba si el archivo es un directorio.
  
• is_executable() Comprueba si el archivo es ejecutable.
  
• is_file() Comprueba si el archivo es un archivo regular.
  
• is_link() Comprueba si el archivo es un enlace.
  
• is_readable() Comprueba si el archivo es legible.
  
• is_uploaded_file() Comprueba si el archivo se cargó mediante HTTP POST.
  
• is_writable() Comprueba si el archivo es escribible.
  
• is_writeable() Alias de is_writable().
  
• lchgrp() Cambia la propiedad de grupo de un enlace simbólico.
  
• lchown() Cambia la propiedad de usuario de un enlace simbólico.
  
• link() Crea un enlace duro.
  
• linkinfo() Devuelve información sobre un enlace duro.
  
• lstat() Devuelve información sobre un archivo o enlace simbólico.
  
• mkdir() Crea un directorio.
  
• move_uploaded_file() Mueve un archivo cargado a una nueva ubicación.
  
• parse_ini_file() Analiza un archivo de configuración.
  
• parse_ini_string() Analiza una cadena de configuración.
  
• pathinfo() Devuelve información sobre una ruta de archivo.
  
• pclose() Cierra un proceso abierto por popen().
  
• popen() Abre un proceso.
  
• readfile() Lee un archivo y lo escribe en el búfer de salida.
  
• readlink() Devuelve el destino de un enlace simbólico.
  
• realpath() Devuelve la ruta absoluta.
  
• realpath_cache_get() Devuelve las entradas de la caché.
  
• realpath_cache_size() Devuelve el tamaño de la caché.
  
• rename() Cambia el nombre de un archivo o directorio.
  
• rewind() Rebobina la posición del puntero del archivo.
  
• rmdir() Elimina un directorio vacío.
  
• set_file_buffer() Establece el tamaño del búfer de un archivo abierto.
  
• stat() Devuelve información sobre un archivo.
  
• symlink() Crea un enlace simbólico.
  
• tempnam() Crea un archivo temporal único.
  
• tmpfile() Crea un archivo temporal único.
  
• touch() Establece la hora de acceso y modificación de un archivo.
  
• umask() Cambia los permisos de archivo.
  
• unlink() Elimina un archivo.

PHP JSON

• json_encode Codifica una variable en JSON.
  
• json_decode Decodifica una cadena con formato JSON y la convierte en una variable de PHP.
  
• json_last_error Devuelve el último error ocurrido.

string json_encode ( $value [, $options = 0 ] )
Parámetros

value: El valor a codificar. Esta función solo es válida para datos codificados en UTF-8.
options: Máscara binaria compuesta por las siguientes constantes: JSON_HEX_QUOT, JSON_HEX_TAG, JSON_HEX_AMP, JSON_HEX_APOS, JSON_NUMERIC_CHECK, JSON_PRETTY_PRINT, JSON_UNESCAPED_SLASHES, JSON_FORCE_OBJECT

<?php
   $arr = array('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5);
   echo json_encode($arr);


    class Emp {
       public $name = "";
       public $hobbies  = "";
       public $birthdate = "";
   }
   $e = new Emp();
   $e->name = "sachin";
   $e->hobbies  = "sports";
   $e->birthdate = date('m/d/Y h:i:s a', "8/5/1974 12:20:03 p");
   $e->birthdate = date('m/d/Y h:i:s a', strtotime("8/5/1974 12:20:03"));

   echo json_encode($e);
?>

mixed json_decode ($json [,$assoc = false [, $depth = 512 [, $options = 0 ]]])
Parámetros

json_string: La cadena JSON a decodificar, debe ser datos codificados en UTF-8.

assoc: Cuando este parámetro es TRUE, se devuelve una matriz; cuando es FALSE, se devuelve un objeto.

depth: Parámetro de tipo entero que especifica la profundidad de recursión.

options: Máscara binaria, actualmente solo compatible con JSON_BIGINT_AS_STRING.

<?php
   $json = '{"a":1,"b":2,"c":3,"d":4,"e":5}';

   var_dump(json_decode($json));
   var_dump(json_decode($json, true));
?>

Más tutoriales

Para tutoriales más detallados, consulte:Tutorial de PHP