3. Los fundamentos de PHP

3.1. Un primer ejemplo

A continuación se muestra un programa que demuestra las características básicas de PHP.

3.1.1. El programa (example_01)

1. <?php
2. 
3. // this is a comment
4. // variable used without being declared
5. $name = "dupont";
6. 
7. // a screen display
8. print "name=$name\n";
9. 
10. // an array with elements of different types
11. $array = array("one", "two", 3, 4);
12. 
13. // its number of elements
14. $n = count($array);
15. 
16. // a loop
17. for ($i = 0; $i < $n; $i++)
18.   print "array[$i] = $array[$i]\n";
19. 
20. // initializing 2 variables with the contents of an array
21. list($string1, $string2) = array("string1", "string2");
22. 
23. // concatenation of the 2 strings
24. $string3 = $string1 . $string2;
25. 
26. // display result
27. print "[$string1,$string2,$string3]\n";
28. 
29. // using the function
30. display($string1);
31. 
32. // the type of a variable can be determined
33. displayType($n);
34. displayType($string1);
35. displayType($array);
36. 
37. // The type of a variable can change during execution
38. $n = "has changed";
39. displayType($n);
40. 
41. // a function can return a result
42. $res1 = f1(4);
43. print "res1=$res1\n";
44. 
45. // a function can return an array of values
46. list($res1, $res2, $res3) = f2();
47. print "(res1,res2,res3)=[$res1,$res2,$res3]\n";
48. 
49. // we could have retrieved these values into an array
50. $t = f2();
51. for ($i = 0; $i < count($t); $i++)
52.   print "t[$i]=$t[$i]\n";
53. 
54. // tests
55. for ($i = 0; $i < count($t); $i++)
56. // displays only strings
57.   if (getType($t[$i]) == "string")
58.     print "t[$i]=$t[$i]\n";
59. 
60. // other tests
61. for ($i = 0; $i < count($t); $i++){
62. // displays only integers greater than 10
63.   if (getType($t[$i]) == "integer" and $t[$i] > 10)
64.     print "t[$i]=$t[$i]\n";
65. }
66. 
67. // a while loop
68. $t = array(8, 5, 0, -2, 3, 4);
69. $i = 0;
70. $sum = 0;
71. while ($i < count($t) and $t[$i] > 0) {
72.   print "t[$i]=$t[$i]\n";
73.   $sum+=$t[$i];   //$sum=$sum+$t[$i]
74.   $i++;             //$i=$i+1
75. }
76. print "sum=$sum\n";
77. 
78. // end of program
79. exit;
80. 
81. //----------------------------------
82. function display($string) {
83.   // display $string
84.   print "string=$string\n";
85. }
86. 
87. //----------------------------------
88. function displayType($variable) {
89.   // displays the type of $variable
90.   print "type[$variable]=" . getType($variable) . "\n";
91. }
92. 
93. //----------------------------------
94. function f1($param) {
95.   // adds 10 to $param
96.   return $param + 10;
97. }
98. 
99. //----------------------------------
100. function f2() {
101.   // returns 3 values
102.   return array("one", 0, 100);
103. }
104. ?>

Los resultados:

1. name=dupont
2. array[0]=one
3. array[1]=two
4. array[2]=3
5. array[3]=4
6. [string1, string2, string1string2]
7. string = string1
8. type[4] = integer
9. type[string1] = string
10. type[Array] = array
11. type[changed]=string
12. res1=14
13. (res1, res2, res3) = [1, 0, 100]
14. t[0] = one
15. t[1] = 0
16. t[2] = 100
17. t[0] = 1
18. t[2] = 100
19. t[0]=8
20. t[1]=5
21. sum=13

Comentarios

• Línea 5: En PHP, no se declaran los tipos de variables. Las variables tienen un tipo dinámico que puede cambiar con el tiempo
• $name representa la variable con el identificador nombre
• Línea 8: Para mostrar texto en la pantalla, puede utilizar la función imprimir o la declaración echo declaración
• Línea 11: La palabra clave *matriz* se utiliza para definir un array. La variable $nombre[$i] representa el $ith del elemento $array matriz.
• línea 14: el count($tabla) devuelve el número de elementos en tabla matriz
• línea 18: las cadenas se encierran entre comillas dobles " o simples '. Dentro de las comillas dobles, las variables $variable pero no dentro de comillas simples.
• línea 21: el lista permite agrupar variables en una lista y asignarles un valor con una sola operación de asignación. Aquí, $cadena1="cadena1" y $cadena2="cadena2".
• línea 24: el operador . es el operador de concatenación de cadenas.
• línea 88: la palabra clave función define una función. Una función puede o no devolver valores utilizando la función devolver declaración. El código de llamada puede ignorar o recuperar los resultados de una función. Una función puede definirse en cualquier parte del código.
• Línea 90: La función predefinida getType($variable) devuelve una cadena que representa el tipo de $variable. Este tipo puede cambiar con el tiempo.
• Línea 79: La función predefinida salida termina el script.

3.2. Ámbito variable

3.2.1. Programa 1 (example_02)

1. <?php
2. 
3. // scope of variables
4. 
5. function f1() {
6.   // we use the global variable $i
7.   $i = &$GLOBALS["i"];
8.   $i++;
9.   $j = 10;
10.   print "f1[i,j]=[$i,$j]\n";
11. }
12. 
13. function f2() {
14.   // we use the global variable $i
15.   $i = &$GLOBALS["i"];
16.   $i++;
17.   $j = 20;
18.   print "f2[i,j]=[$i,$j]\n";
19. }
20. 
21. function f3() {
22.   // we use a local variable $i
23.   $i = 4;
24.   $j = 30;
25.   print "f3[i,j]=[$i,$j]\n";
26. }
27. 
28. // tests
29. $i = 0;
30. $j = 0; // these two variables are known to a function f via the $GLOBALS array
31. f1();
32. f2();
33. f3();
34. print "test[i,j]=[$i,$j]\n";
35. ?>

Los resultados:

1. f1[i,j]=[1,10]
2. f2[i,j]=[2,20]
3. f3[i,j]=[4,30]
4. test[i,j] = [2,0]

Comentarios

• Líneas 29-30: definir dos variables, $i y $j, en el programa principal. Estas variables no se conocen dentro de las funciones. Así, en la línea 9, la variable $j en función f1 es una variable local de la función f1 y es diferente de la variable $j en el programa principal. Una función puede acceder a una variable $variable desde el programa principal a través de una matriz de variables globales llamada $GLOBALS. En la línea 7, la notación $GLOBALS["i"] se refiere a la variable global $i del programa principal. Si escribimos

$i=$GLOBALS["i"]

una variable local $i se le asigna el valor de la variable global $i. Se trata de dos variables diferentes, y modificando la variable local $i no modificará la variable global $i. La notación

$i=&Globals["i"]

hace que la variable local $i tenga la misma dirección de memoria que la variable global $i. Manipulación de la variable local $i equivale entonces a manipular la variable global $i.

3.2.2. Programa 2 (example_03)

1. <?php
2. 
3. // A variable's scope is global to code blocks
4. $i = 0; {
5.   $i = 4;
6.   $i++;
7. }
8. print "i=$i\n";
9. ?>

Los resultados:

i=5

Comentarios

En algunos lenguajes, una variable definida entre llaves tiene un ámbito limitado a esas llaves: no es accesible fuera de ellas. Los resultados anteriores muestran que éste no es el caso en PHP. La variable $i definida en la línea 5 dentro de las llaves es la misma que la utilizada en las líneas 4 y 8 fuera de ellas.

3.3. Matrices

3.3.1. Matrices unidimensionales clásicas (example_04)

1. <?php
2. 
3. // classic arrays
4. // initialization
5. $tab1 = array(0, 1, 2, 3, 4, 5);
6. 
7. // loop - 1
8. print "tab1 has " . count($tab1) . " elements\n";
9. for ($i = 0; $i < count($tab1); $i++)
10.   print "tab1[$i]=$tab1[$i]\n";
11. 
12. // loop - 2
13. print "tab1 has " . count($tab1) . " elements\n";
14. reset($tab1);
15. while (list($key, $value) = each($tab1))
16.   print "tab1[$key]=$value\n";
17. 
18. // adding elements
19. $tab1[] = $i++;
20. $tab1[] = $i++;
21. 
22. // loop - 3
23. print "tab1 has " . count($tab1) . " elements\n";
24. $i = 0;
25. foreach ($tab1 as $element) {
26.   print "tab1[$i]=$element\n";
27.   $i++;
28. }
29. 
30. // remove last element
31. array_pop($tab1);
32. 
33. // loop - 4
34. print "tab1 has " . count($tab1) . " elements\n";
35. for ($i = 0; $i < count($tab1); $i++)
36.   print "tab1[$i]=$tab1[$i]\n";
37. 
38. // remove first element
39. array_shift($tab1);
40. 
41. // loop - 5
42. print "tab1 has " . count($tab1) . " elements\n";
43. for ($i = 0; $i < count($tab1); $i++)
44.   print "tab1[$i] = $tab1[$i]\n";
45. 
46. // Add to the end of the array
47. array_push($tab1, -2);
48. 
49. // loop - 6
50. print "tab1 has " . count($tab1) . " elements\n";
51. for ($i = 0; $i < count($tab1); $i++)
52.   print "tab1[$i]=$tab1[$i]\n";
53. 
54. // Add to the beginning of the array
55. array_unshift($tab1, -1);
56. 
57. // loop - 7
58. print "tab1 has " . count($tab1) . " elements\n";
59. for ($i = 0; $i < count($tab1); $i++)
60.   print "tab1[$i]=$tab1[$i]\n";
61. ?>

Los resultados:

1. tab1 has 6 elements
2. tab1[0]=0
3. tab1[1]=1
4. tab1[2]=2
5. tab1[3]=3
6. tab1[4] = 4
7. tab1[5]=5
8. tab1 has 6 elements
9. tab1[0] = 0
10. tab1[1] = 1
11. tab1[2]=2
12. tab1[3]=3
13. tab1[4] = 4
14. tab1[5]=5
15. tab1 has 8 elements
16. tab1[0] = 0
17. tab1[1]=1
18. tab1[2]=2
19. tab1[3]=3
20. tab1[4] = 4
21. tab1[5]=5
22. tab1[6]=6
23. tab1[7]=7
24. tab1 has 7 elements
25. tab1[0]=0
26. tab1[1]=1
27. tab1[2]=2
28. tab1[3]=3
29. tab1[4] = 4
30. tab1[5]=5
31. tab1[6]=6
32. tab1 has 6 elements
33. tab1[0]=1
34. tab1[1]=2
35. tab1[2]=3
36. tab1[3]=4
37. tab1[4] = 5
38. tab1[5]=6
39. tab1 has 7 elements
40. tab1[0]=1
41. tab1[1]=2
42. tab1[2]=3
43. tab1[3]=4
44. tab1[4] = 5
45. tab1[5]=6
46. tab1[6]=-2
47. tab1 has 8 elements
48. tab1[0]=-1
49. tab1[1]=1
50. tab1[2]=2
51. tab1[3] = 3
52. tab1[4] = 4
53. tab1[5]=5
54. tab1[6]=6
55. tab1[7]=-2

Comentarios

El programa anterior muestra operaciones para manipular una matriz de valores. Hay dos notaciones para matrices en PHP:

1. $array = array("one", 2, "three")
2. $opposites = array("small" => "large", "beautiful" => "ugly", "expensive" => "cheap")

La matriz 1 se denomina matriz y la matriz 2 se denomina diccionario, donde los elementos se denotan como clave => valor. La notación $opposites["beautiful"] se refiere al valor asociado a la clave "hermoso" Aquí, ese valor es la cadena "feo" La matriz 1 es simplemente una variante del diccionario y podría escribirse como:

$array=array(0=>"one",1=>2,2=>"three")

Así, tenemos $array[2]="tres". En última instancia, sólo hay diccionarios. En el caso de una matriz clásica de n las claves son los enteros del rango [0,n-1].

• Línea 15: El each($array) le permite iterar sobre un diccionario. En cada llamada, devuelve un par (clave, valor) del mismo.
• Línea 14: El reset($diccionario) establece el valor cada al primer par (clave, valor) del diccionario.
• línea 15: el mientras que se detiene cuando cada devuelve un par vacío al final del diccionario.
• línea 19: la notación $array[]=valor añade el elemento valor como último elemento de $array.
• línea 25: se itera sobre la matriz utilizando una función foreach. Esta sintaxis permite iterar sobre un diccionario, y por tanto sobre un array, utilizando dos sintaxis:

foreach($dictionary as $key=>$value)
foreach($array as $value)

La primera sintaxis devuelve un (clave,valor) en cada iteración, mientras que la segunda sintaxis devuelve sólo el par valor del diccionario.

• Línea 31: El array_pop($array) elimina el último elemento de $array
• línea 39: el array_shift($array) elimina el primer elemento de $array
• línea 47: el array_push($array,valor) la función añade valor como último elemento de $array
• línea 39: el array_unshift($array,valor) la función añade valor como primer elemento de $array

3.3.2. El diccionario (example_05)

1. <?php
2. 
3. // dictionaries
4. $couples = array("Pierre" => "Gisèle", "Paul" => "Virginie", "Jacques" => "Lucette", "Jean" => "");
5. 
6. // loop - 1
7. print "Number of elements in the dictionary: " . count($couples) . "\n";
8. reset($couples);
9. while (list($key, $value) = each($couples))
10.   print "spouses[$key]=$value\n";
11. 
12. // Sort the dictionary by key
13. ksort($pairs);
14. 
15. // loop - 2
16. reset($pairs);
17. while (list($key, $value) = each($pairs))
18.   print "pairs[$key]=$value\n";
19. 
20. // list of dictionary keys
21. $keys = array_keys($pairs);
22. for ($i = 0; $i < count($keys); $i++)
23.   print "keys[$i] = $keys[$i]\n";
24. 
25. // list of dictionary values
26. $values = array_values($pairs);
27. for ($i = 0; $i < count($values); $i++)
28.   print "values[$i]=$values[$i]\n";
29. 
30. // search for a key
31. exists($pairs, "Jacques");
32. exists($pairs, "Lucette");
33. exists($couples, "Jean");
34. 
35. // delete a key-value pair
36. unset($spouses["Jean"]);
37. print "Number of elements in the dictionary: " . count($spouses) . "\n";
38. foreach ($couples as $key => $value) {
39.   print "spouses[$key]=$value\n";
40. }
41. 
42. // end
43. exit;
44. 
45. function exists($couples, $husband) {
46.   // checks if the key $husband exists in the $spouses dictionary
47.   if (isset($spouses[$husband]))
48.     print "The key [$mari] exists with the value [$conjoints[$mari]]\n";
49.   else
50.     print "The key [$husband] does not exist\n";
51. }
52. 
53. ?>

Los resultados:

1. Number of elements in the dictionary: 4
2. spouses[Pierre]=Gisèle
3. spouses[Paul]=Virginie
4. spouses[Jacques]=Lucette
5. spouses[Jean]=
6. spouses[Jacques]=Lucette
7. spouses[Jean]=
8. spouses[Paul]=Virginie
9. spouses[Pierre]=Gisèle
10. keys[0]=Jacques
11. keys[1]=Jean
12. keys[2]=Paul
13. keys[3]=Pierre
14. values[0]=Lucette
15. values[1]=
16. values[2]=Virginie
17. values[3]=Gisèle
18. The key [Jacques] exists and is associated with the value [Lucette]
19. The key [Lucette] does not exist
20. The key [Jean] exists associated with the value []
21. Number of elements in the dictionary: 3
22. spouses[Jacques]=Lucette
23. spouses[Paul]=Virginie
24. spouses[Pierre]=Gisèle

Comentarios

El código anterior aplica a un diccionario lo que antes vimos para un array simple. Sólo comentaremos las novedades:

• línea 13: el ksort (ordenación por clave) ordena un diccionario en el orden natural de las claves.
• línea 21: el array_keys($diccionario) devuelve la lista de claves del diccionario en forma de matriz
• línea 26: el array_values($diccionario) devuelve la lista de valores del diccionario en forma de matriz
• línea 47: el isset($variable) devuelve verdadero si $variable y falso en caso contrario.
• Línea 36: El unset($variable) borra el archivo $variable.

3.3.3. Matrices multidimensionales (example_06)

1. <?php
2. 
3. // Classic multidimensional arrays
4. // initialization
5. $multi = array(array(0, 1, 2), array(10, 11, 12, 13), array(20, 21, 22, 23, 24));
6. // iteration
7. for ($i1 = 0; $i1 < count($multi); $i1++)
8.   for ($i2 = 0; $i2 < count($multi[$i1]); $i2++)
9.     print "multi[$i1][$i2]=" . $multi[$i1][$i2] . "\n";
10. // multidimensional arrays
11. // initialization
12. $multi = array("zero" => array(0, 1, 2), "one" => array(10, 11, 12, 13), "two" => array(20, 21, 22, 23, 24));
13. // iteration
14. foreach ($multi as $key => $value)
15.   for ($i2 = 0; $i2 < count($value); $i2++)
16.     print "multi[$key][$i2]=" . $multi[$key][$i2] . "\n";
17. ?>

Resultados:

1. multi[0][0]=0
2. multi[0][1]=1
3. multi[0][2]=2
4. multi[1][0]=10
5. multi[1][1]=11
6. multi[1][2]=12
7. multi[1][3]=13
8. multi[2][0]=20
9. multi[2][1]=21
10. multi[2][2]=22
11. multi[2][3]=23
12. multi[2][4]=24
13. multi[zero][0]=0
14. multi[zero][1]=1
15. multi[zero][2]=2
16. multi[one][0]=10
17. multi[one][1]=11
18. multi[one][2]=12
19. multi[one][3]=13
20. multi[two][0]=20
21. multi[two][1]=21
22. multi[two][2]=22
23. multi[two][3]=23
24. multi[two][4]=24

Comentarios

• línea 5: los elementos del multi son a su vez matrices
• línea 12: el multi se convierte en un diccionario (clave, valor) donde cada valor es una matriz

3.3.4. Enlaces entre cadenas y matrices (example_07)

1. <?php
2. 
3. // string to array
4. $string = "1:2:3:4";
5. $array = explode(":", $string);
6. 
7. // iterate through array
8. print "array has " . count($tab) . " elements\n";
9. for ($i = 0; $i < count($tab); $i++)
10.   print "tab[$i]=$tab[$i]\n";
11. 
12. // array to string
13. $string2 = implode(":", $tab);
14. print "string2=$string2\n";
15. 
16. // let's add an empty field
17. $string.=":";
18. print "string=$string\n";
19. $tab = explode(":", $string);
20. 
21. // loop through the array
22. print "tab has " . count($tab) . " elements\n";
23. for ($i = 0; $i < count($tab); $i++)
24.   print "tab[$i]=$tab[$i]\n"; // we now have 5 elements, the last one being empty
25.   
26. // let's add an empty field again
27. $string.=":";
28. print "string=$string\n";
29. $tab = explode(":", $string);
30. 
31. // iterate through the array
32. print "tab a " . count($tab) . " elements\n";
33. for ($i = 0; $i < count($tab); $i++)
34.   print "tab[$i]=$tab[$i]\n"; // we now have 6 elements, the last two being empty
35. ?>

Resultados:

1. tab has 4 elements
2. tab[0]=1
3. tab[1]=2
4. tab[2]=3
5. tab[3]=4
6. string2 = 1:2:3:4
7. array=1:2:3:4:
8. tab with 5 elements
9. tab[0]=1
10. tab[1]=2
11. tab[2]=3
12. tab[3]=4
13. tab[4]=
14. string = 1:2:3:4::
15. tab has 6 elements
16. tab[0]=1
17. tab[1]=2
18. tab[2]=3
19. tab[3]=4
20. tab[4]=
21. tab[5]=

Comentarios

• Línea 5: El explode($separador,$cadena) recupera los campos de $cadena separados por $separador. Así, explode(":",$cadena) devuelve los elementos de $cadena separadas por la cadena ":" como una matriz.
• La función implode($separador,$matriz) realiza la operación contraria a la función explode. Devuelve una cadena formada por los elementos de $array separados por $separador.

3.4. Cuerdas

3.4.1. Sintaxis (example_08)

1. <?php
2. 
3. // string notation
4. $string1 = "one";
5. $string2 = 'one';
6. print "[$string1,$string2]\n";
7. ?>

Resultados:

[one,one]

3.4.2. Comparación (example_09)

1. <?php
2. 
3. // string comparison tests
4. compare("abcd", "abcd");
5. compare("", "");
6. compare("1", "");
7. exit;
8. 
9. function compare($string1, $string2) {
10.   // compare string1 and string2
11.   if ($string1 == $string2)
12.     print "[$string1] is equal to [$string2]\n";
13.   else
14.     print "[$string1] is different from [$string2]\n";
15. }
16. 
17. ?>

Resultados:

1. [abcd] is equal to [abcd]
2. [] is equal to []
3. [1] is not equal to []

3.5. Expresiones regulares (example_10)

1. <?php
2. 
3. // Regular expressions in PHP
4. // extract the different fields from a string
5. 
6. // the pattern: a sequence of digits surrounded by any characters
7. // we only want to extract the sequence of digits
8. $pattern = "/(\d+)/";
9. // compare the string to the pattern
10. compare($pattern, "xyz1234abcd");
11. compare($pattern, "12 34");
12. compare($pattern, "abcd");
13. 
14. // the pattern: a sequence of digits surrounded by any characters
15. // We want the sequence of digits as well as the fields that follow and precede it
16. $pattern = "/^(.*?)(\d+)(.*?)$/";
17. // we match the string against the pattern
18. compare($pattern, "xyz1234abcd");
19. compare($pattern, "12 34");
20. compare($pattern, "abcd");
21. 
22. // the pattern - a date in dd/mm/yy format
23. $pattern = "/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/";
24. compare($template, "10/05/97");
25. compare($template, " 04/04/01 ");
26. compare($pattern, "5/1/01");
27. 
28. // the pattern - a decimal number
29. $pattern = "/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/";
30. compare($pattern, "187.8");
31. compare($pattern, "-0.6");
32. compare($pattern, "4");
33. compare($pattern, ".6");
34. compare($pattern, "4.");
35. compare($model, " + 4");
36. 
37. // end
38. exit;
39. 
40. // --------------------------------------------------------------------------
41. function compare($pattern, $string) {
42.   // compares the string $string to the pattern $pattern
43.   // compares the string to the pattern
44.   $match = preg_match($pattern, $string, $fields);
45.   // display results
46.   print "\nResults($pattern,$string)\n";
47.   if ($match) {
48.     for ($i = 0; $i < count($fields); $i++)
49.       print "fields[$i] = $fields[$i]\n";
50.   } else
51.     print "The string [$string] does not match the pattern [$pattern]\n";
52. }
53. ?>

Resultados:

1. Results(/(\d+)/,xyz1234abcd)
2. fields[0]=1234
3. fields[1]=1234
4. 
5. Results(/(\d+)/,12 34)
6. fields[0]=12
7. fields[1]=12
8. 
9. Results(/(\d+)/,abcd)
10. The string [abcd] does not match the pattern [/(\d+)/]
11. 
12. Results(/^(.*?)(\d+)(.*?)$/,xyz1234abcd)
13. fields[0]=xyz1234abcd
14. fields[1]=xyz
15. fields[2]=1234
16. fields[3]=abcd
17. 
18. Results(/^(.*?)(\d+)(.*?)$/,12 34)
19. fields[0]=12 34
20. fields[1]=
21. fields[2]=12
22. fields[3] = 34
23. 
24. Results(/^(.*?)(\d+)(.*?)$/,abcd)
25. The string [abcd] does not match the pattern [/^(.*?)(\d+)(.*?)$/]
26. 
27. Results(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,10/05/97)
28. fields[0]=10/05/97
29. fields[1]=10
30. fields[2]=05
31. fields[3]=97
32. 
33. Results(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/, 04/04/01 )
34. fields[0]= 04/04/01  
35. fields[1]=04
36. fields[2]=04
37. fields[3]=01
38. 
39. Results(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,5/1/01)
40. The string [5/1/01] does not match the pattern [/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/]
41. 
42. Results(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,187.8)
43. fields[0]=187.8
44. fields[1]=
45. fields[2]=187.8
46. 
47. Results(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,-0.6)
48. fields[0]=-0.6
49. fields[1]=-
50. fields[2]=0.6
51. 
52. Results(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,4)
53. fields[0]=4
54. fields[1]=
55. fields[2]=4
56. 
57. Results(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,.6)
58. fields[0]=.6
59. fields[1]=
60. fields[2]=.6
61. 
62. Results(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,4.)
63. fields[0]=4.
64. fields[1]=
65. fields[2]=4.
66. 
67. Results(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/, + 4)
68. fields[0] = + 4
69. fields[1]=+
70. fields[2]=4

Comentarios

• Líneas 3-4: Aquí utilizamos expresiones regulares para extraer los distintos campos de una cadena. Las expresiones regulares nos permiten superar las limitaciones de la función implosionar función. El principio es comparar una cadena con otra cadena llamada un patrón utilizando el preg_match función:

$matches = preg_match($pattern, $string, $fields);

En preg_match función devuelve un valor booleano que indica si el patrón en el cadena. Si es así, $campos[0] representa la subcadena que coincide con el patrón. Además, si el patrón contiene subpatrones encerrados entre paréntesis, $campos[1] es la parte de $cadena correspondiente al primero subpatrón, $campos[2] es la parte de $cadena correspondiente al segundo subpatrón, y así sucesivamente...

Considere la primero ejemplo. El patrón se define en la línea 8: denota una secuencia de uno o más dígitos (+) (\d) situados en cualquier lugar de una cadena. Además, el patrón define un sub-patrón encerrado entre paréntesis.

• Línea 10: el patrón /(\d+)/ (una secuencia de uno o más dígitos en cualquier lugar de la cadena) se compara con la cadena "xyz1234abcd". Vemos que la subcadena 1234 coincide con el patrón. Por lo tanto, $fields[0] será igual a "1234". Además, el patrón tiene subpatrones encerrados entre paréntesis. Tendremos $campos[1]="1234".
• Línea 11: El modelo /(\d+)/ se compara con la cadena "12 34". Vemos que las subcadenas 12 y 34 coinciden con el patrón. La comparación se detiene en la primera subcadena que coincide con el patrón. Por lo tanto, $campos[0] = 12 y $campos[1] = 12.
• Línea 12: El modelo /(\d+)/ se compara con la cadena "abcd". No se encuentra ninguna coincidencia.

Vamos a explicar los patrones utilizados en el resto del código:

$pattern = "/^(.*?)(\d+)(.*?)$/";

inicio de cadena (^), luego 0 o más (*) caracteres arbitrarios (.), luego 1 o más (+) dígitos, luego de nuevo 0 o más (*) caracteres arbitrarios (.). El patrón (.*) indica 0 o más caracteres arbitrarios. Un patrón de este tipo coincide con cualquier cadena. Así, el patrón /^(.*)(\d+)(.*)$/ nunca se encontrará porque el primer subpatrón (.*) consumirá toda la cadena. El patrón (.*?)(\d+) indica 0 o más caracteres arbitrarios hasta el siguiente subpatrón (?), en este caso \d+. Por lo tanto, los dígitos ya no son capturados por el patrón (.*). Por lo tanto, el patrón anterior coincide con [inicio de cadena (^), una secuencia de cualquier carácter (.*?), una secuencia de uno o más dígitos (\d+), una secuencia de cualquier carácter (.*?), final de cadena ($)].

$pattern = "/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/";

coincide con [inicio de cadena (^), 2 dígitos (\d\d), el carácter / (\/), 2 dígitos, /, 2 dígitos, una secuencia de 0 o más espacios (\s*), final de cadena ($)]

$pattern = "/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/";

[inicio de cadena (^), 0 o más espacios (\s*), un signo + o - [+|-] que aparezca 0 o 1 vez (?), una secuencia de 0 o más espacios (\s*), 1 o más dígitos seguidos de un punto decimal seguido de cero o más dígitos (\d+\.\d*) o (|) un punto decimal (\.) seguido de uno o más dígitos (\d+) o (|) uno o más dígitos (\d+), una secuencia de 0 o más espacios (\s*)].

3.6. Modo de paso de parámetros de función (example_11)

1. <?php
2. 
3. // parameter passing mode
4. 
5. function f(&$i, $j) {
6.   // $i will be passed by reference
7.   // $j will be passed by value
8.   $i++;
9.   $j++;
10.   print "f[i,j]=[$i,$j]\n";
11. }
12. 
13. // ----------------------------------------tests
14. $i = 0;
15. $j = 0;
16. // $i and $j passed by value
17. f($i, $j);
18. print "test[i,j]=[$i,$j]\n";
19. ?>

Resultados:

1. f[i,j]=[1,1]
2. test[i,j]=[1,0]

Comentarios

El código anterior muestra las dos formas de pasar parámetros a una función. Consideremos el siguiente ejemplo:

1. function f(&$a,$b){
2. …
3. }
4. 
5. // main program
6. $i=10; $j=20;
7. f($i, $j);

• línea 1: define los parámetros formales $a y $b de la función f. Esta función manipula estos dos parámetros formales y devuelve un resultado.
• línea 7: llama a la función f con dos parámetros reales $i y $j. Los enlaces entre los parámetros formales ($a, $b) y los parámetros reales ($i, $j) se definen en la línea 7
• &$a: el símbolo & indica que el parámetro formal $a tomará el valor de la dirección del parámetro real $i. En otras palabras, $a y $i son dos referencias a la misma posición de memoria. Manipular el parámetro formal $a equivale a manipular el parámetro real $i. Esto se demuestra con la ejecución del código. Este método de paso es adecuado para parámetros de salida y grandes conjuntos de datos como arrays y diccionarios. Este método de paso se denomina pass-by-reference.
• $b: El parámetro formal $b tomará el valor del parámetro real $j. Esto es pasar por valor. Los parámetros formales y reales son dos variables diferentes. La manipulación del parámetro formal $b no tiene ningún efecto sobre el parámetro real $j. Esto se demuestra por la ejecución del código. Este modo de paso es adecuado para los parámetros de entrada.
• Considere la intercambiar que recibe dos parámetros formales $a y $b. La función intercambia los valores de estos dos parámetros. Así, durante una llamada a swap($i,$j), el código de llamada espera que se intercambien los valores de los dos parámetros reales. Se trata, por tanto, de parámetros de salida (se modifican). Por lo tanto, escribiremos

function swap(&$a,&$b){....}

3.7. Resultados devueltos por una función (example_12)

1. <?php
2. 
3. // results returned by a function
4. // a function can return multiple values in an array
5. list($res1, $res2, $res3) = f1(10);
6. print "[$res1,$res2,$res3]\n";
7. $res = f1(10);
8. for ($i = 0; $i < count($res); $i++)
9.   print "res[$i]=$res[$i]\n";
10. 
11. // a function can return a pseudo-object
12. $res = f2(10);
13. print "[$res->res1,$res->res2,$res->res3]\n";
14. 
15. // end
16. exit;
17. 
18. // function f1
19. function f1($value) {
20.   // returns an array ($value+1, $value+2, $value+3)
21.   return array($value + 1, $value + 2, $value + 3);
22. }
23. 
24. // function f2
25. function f2($value) {
26.   // returns a pseudo-object ($value+1, $value+2, $value+3)
27.   $res->res1 = $value + 1;
28.   ;
29.   $res->res2 = $value + 2;
30.   $res->res3 = $value + 3;
31.   // returns the object
32.   return $res;
33. }
34. 
35. ?>

Resultados

1. [11,12,13]
2. res[0]=11
3. res[1]=12
4. res[2]=13
5. [11,12,13]

Comentarios

• El programa anterior muestra que una función PHP puede devolver un conjunto de resultados en lugar de uno solo, en forma de array o de objeto. El concepto de objeto se explica con más detalle a continuación
• líneas 19-22: la función f1 devuelve varios valores en forma de matriz
• líneas 25-33: la función f2 devuelve varios valores en forma de objeto

3.8. Archivos de texto (example_13)

1. <?php
2. 
3. // sequential processing of a text file
4. // This is a set of lines in the format login:pwd:uid:gid:infos:dir:shell
5. // Each line is stored in a dictionary in the form login => uid:gid:infos:dir:shell
6. 
7. // We set the file name
8. $INFOS = "infos.txt";
9. 
10. // open it for writing
11. if (!$fic = fopen($INFOS, "w")) {
12.   print "Error opening file $INFOS for writing\n";
13.   exit;
14. }
15. 
16. // generate arbitrary content
17. for ($i = 0; $i < 100; $i++)
18.   fputs($fic, "login$i:pwd$i:uid$i:gid$i:infos$i:dir$i:shell$i\n");
19. // close the file
20. fclose($fic);
21. 
22. // process it - fgets preserves the end-of-line character
23. // this prevents an empty string from being retrieved when reading a blank line
24. // open it for writing
25. if (!$fic = fopen($INFOS, "r")) {
26.   print "Error opening file $INFOS for reading\n";
27.   exit;
28. }
29. while ($line = fgets($fic, 1000)) {
30.   // remove the end-of-line character if present
31.   $line = cutNewLineChar($line);
32.   // put the line into an array
33.   $infos = explode(":", $line);
34.   // retrieve the login
35.   $login = array_shift($info);
36.   // ignore the password
37.   array_shift($info);
38.   // create an entry in the dictionary
39.   $dico[$login] = $infos;
40. }
41. // close it
42. fclose($fic);
43. 
44. // use the dictionary
45. displayInfo($dico, "login10");
46. displayInfo($dico, "X");
47. 
48. // end
49. exit;
50. 
51. // --------------------------------------------------------------------------
52. function displayInfo($dico, $key) {
53.   // displays the value associated with key in the $dico dictionary if it exists
54.   if (isset($dico[$key])) {
55.     // value exists - is it an array?
56.     $value = $dico[$key];
57.     if (is_array($value)) {
58.       print "[$key," . join(":", $value) . "]\n";
59.     } else {
60.       // $value is not an array
61.       print "[$key,$value]\n";
62.     }
63.   } else {
64.     // $key is not a key in the $dico dictionary
65.     print "The key [$key] does not exist\n";
66.   }
67. }
68. 
69. // --------------------------------------------------------------------------
70. function cutNewLinechar($line) {
71.   // remove the end-of-line character from $line if it exists
72.   $L = strlen($line); // line length
73.   while (substr($line, $L - 1, 1) == "\n" or substr($line, $L - 1, 1) == "\r") {
74.     $line = substr($line, 0, $L - 1);
75.     $L--;
76.   }
77.   // end
78.   return($line);
79. }
80. 
81. ?>

El archivo infos.txt:

login0:pwd0:uid0:gid0:infos0:dir0:shell0
login1:pwd1:uid1:gid1:infos1:dir1:shell1
login2:pwd2:uid2:gid2:infos2:dir2:shell2
...
login98:pwd98:uid98:gid98:infos98:dir98:shell98
login99:pwd99:uid99:gid99:infos99:dir99:shell99

Los resultados:

1. [login10,uid10:gid10:infos10:dir10:shell10]
2. The key [X] does not exist

Comentarios

• Línea 11: fopen(nombredearchivo, "w") abre el archivo nombre de archivo para escribir (w = escribir). Si el fichero no existe, se crea. Si existe, se borra su contenido. Si la creación falla, fopen devuelve falso. En la declaración si (!$fic = fopen($INFOS, "w")) {…}, hay dos operaciones sucesivas: 1) $fic=fopen(..) 2) if( ! $fic) {...}
• Línea 18: fputs($fic,$cadena) escribe cadena a la $fic archivo.
• Línea 20: fclose($fic) cierra el $fic archivo.
• línea 25: fopen(nombredearchivo, "r") abre el nombre de archivo para lectura (r=leer). Si la apertura falla (el fichero no existe), fopen devuelve un valor de falso.
• línea 29: fgets($fic,1000) lee la siguiente línea del fichero, limitada a 1000 caracteres. En la operación mientras que ($línea = fgets($fic, 1000)) {…}, hay dos operaciones sucesivas: 1) $línea = fgets(...) 2) while ( ! $línea). Una vez leído el último carácter del fichero, se ejecuta la operación fgets función devuelve una cadena vacía y mientras que bucle paradas.
• Línea 31: El fgets función lee una línea de texto, incluyendo el carácter de nueva línea. La función cutNewLineChar de las líneas 70-79 elimina cualquier carácter de nueva línea.
• línea 72: el strlen($cadena) función devuelve el número de caracteres en $cadena.
• Línea 73: El substr($línea, $posición, $tamaño) función devuelve $tamaño caracteres de $línea, a partir del carácter #$posición, donde el primero es #0. En máquinas Windows, el marcador de fin de línea es "\r\n". En máquinas Unix, es la cadena "\n".
• Línea 35: El array_shift($array) función elimina el primero elemento de $array y lo devuelve como resultado.
• línea 37: el array_shift($array) función pero su resultado se ignora
• Línea 57: El is_array($variable) función devuelve verdadero si $variable es una matriz, falso de lo contrario.
• Línea 58: El únase a función hace lo mismo que el implosionar función que encontramos antes