Skip to content

3. Noções básicas de PHP

3.1. Um primeiro exemplo

Segue-se um programa que demonstra as funcionalidades básicas do PHP.

3.1.1. O programa (example_01)


<?php
 
// this is a comment
// variable used without being declared
$nom = "dupont";
 
// a screen display
print "nom=$nom\n";
 
// an array with elements of different types
$tableau = array("un", "deux", 3, 4);
 
// its number of elements
$n = count($tableau);
 
// a loop
for ($i = 0; $i < $n; $i++)
  print "tableau[$i]=$tableau[$i]\n";
 
// initialize 2 variables with the contents of an array
list($chaine1, $chaine2) = array("chaine1", "chaine2");
 
// concatenation of the 2 strings
$chaine3 = $chaine1 . $chaine2;
 
// result display
print "[$chaine1,$chaine2,$chaine3]\n";
 
// use function
affiche($chaine1);
 
// the type of a variable can be known
afficheType($n);
afficheType($chaine1);
afficheType($tableau);
 
// the type of a variable can change at runtime
$n = "a changé";
afficheType($n);
 
// a function can return a result
$res1 = f1(4);
print "res1=$res1\n";
 
// a function can return a table of values
list($res1, $res2, $res3) = f2();
print "(res1,res2,res3)=[$res1,$res2,$res3]\n";
 
// we could have retrieved these values in a table
$t = f2();
for ($i = 0; $i < count($t); $i++)
  print "t[$i]=$t[$i]\n";
 
// testing
for ($i = 0; $i < count($t); $i++)
// displays only channels
  if (getType($t[$i]) == "string")
    print "t[$i]=$t[$i]\n";
 
// other tests
for ($i = 0; $i < count($t); $i++){
// displays only integers >10
  if (getType($t[$i]) == "integer" and $t[$i] > 10)
    print "t[$i]=$t[$i]\n";
}
 
// a while loop
$t = array(8, 5, 0, -2, 3, 4);
$i = 0;
$somme = 0;
while ($i < count($t) and $t[$i] > 0) {
  print "t[$i]=$t[$i]\n";
  $somme+=$t[$i];   //$s//$somme=$somme+$t[$i]
  $i++;             //$i=$i+1
}
print "somme=$somme\n";
 
// end of program
exit;
 
//----------------------------------
function affiche($chaine) {
  // displays $chaine
  print "chaine=$chaine\n";
}
 
//----------------------------------
function afficheType($variable) {
  // displays the type of $variable
  print "type[$variable]=" . getType($variable) . "\n";
}
 
//----------------------------------
function f1($param) {
  // adds 10 to $param
  return $param + 10;
}
 
//----------------------------------
function f2() {
  // returns 3 values
  return array("un", 0, 100);
}
?>

Os resultados:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
nom=dupont
tableau[0]=un
tableau[1]=deux
tableau[2]=3
tableau[3]=4
[chaine1,chaine2,chaine1chaine2]
chaine=chaine1
type[4]=integer
type[chaine1]=string
type[Array]=array
type[a changé]=string
res1=14
(res1,res2,res3)=[un,0,100]
t[0]=un
t[1]=0
t[2]=100
t[0]=un
t[2]=100
t[0]=8
t[1]=5
somme=13

Comentários

  • Linha 5: Em PHP, os tipos de variáveis não são declarados. As variáveis têm um tipo dinâmico que pode mudar ao longo do tempo
  • $name representa a variável com o identificador name
  • Linha 8: Para exibir texto no ecrã, pode usar a instrução print ou a instrução echo
  • Linha 11: A palavra-chave *array* é utilizada para definir uma matriz. A variável $name[$i] representa o $i-ésimo elemento da matriz $array.
  • Linha 14: a função count($tableau) devolve o número de elementos na matriz $tableau
  • Linha 18: as cadeias de caracteres são colocadas entre aspas duplas " ou aspas simples '. Dentro das aspas duplas, as variáveis $variable são avaliadas, mas não dentro das aspas simples.
  • linha 21: a função list permite agrupar variáveis numa lista e atribuir-lhes um valor com uma única operação de atribuição. Aqui, $string1="string1" e $string2="string2".
  • linha 24: o operador . é o operador de concatenação de cadeias de caracteres.
  • linha 88: a palavra-chave function define uma função. Uma função pode ou não devolver valores utilizando a instrução return. O código de chamada pode ignorar ou recuperar os resultados de uma função. Uma função pode ser definida em qualquer parte do código.
  • Linha 90: A função predefinida getType($variable) devolve uma cadeia de caracteres que representa o tipo de $variable. Este tipo pode mudar ao longo do tempo.
  • Linha 79: A função predefinida exit encerra o script.

3.2. Âmbito da variável

3.2.1. Programa 1 (example_02)


<?php
 
// variable scope
 
function f1() {
  // we use the global variable $i
  $i = &$GLOBALS["i"];
  $i++;
  $j = 10;
  print "f1[i,j]=[$i,$j]\n";
}
 
function f2() {
  // we use the global variable $i
  $i = &$GLOBALS["i"];
  $i++;
  $j = 20;
  print "f2[i,j]=[$i,$j]\n";
}
 
function f3() {
  // we use a local variable $i
  $i = 4;
  $j = 30;
  print "f3[i,j]=[$i,$j]\n";
}
 
// tests
$i = 0;
$j = 0;  /// these two variables are known to a function f via the table $GLOBALS
f1();
f2();
f3();
print "test[i,j]=[$i,$j]\n";
?>

Os resultados:

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

Comentários

  • Linhas 29–30: definem duas variáveis, $i e $j, no programa principal. Estas variáveis não são conhecidas dentro das funções. Assim, na linha 9, a variável $j na função f1 é uma variável local da função f1 e é diferente da variável $j no programa principal. Uma função pode aceder a uma variável $variable do programa principal através de uma matriz de variáveis globais chamada $GLOBALS. Na linha 7, a notação $GLOBALS["i"] refere-se à variável global $i do programa principal. Se escrevermos 
$i=$GLOBALS["i"]

à variável local $i é atribuído o valor da variável global $i. Trata-se de duas variáveis diferentes, e a modificação da variável local $i não alterará a variável global $i. A notação

$i=&Globals["i"]

faz com que a variável local $i tenha o mesmo endereço de memória que a variável global $i. Manipular a variável local $i é, então, equivalente a manipular a variável global $i.

3.2.2. Programa 2 (example_03)


<?php
 
// the scope of a variable is global to code blocks
$i = 0; {
  $i = 4;
  $i++;
}
print "i=$i\n";
?>

Os resultados:

i=5

Comentários

Em algumas linguagens, uma variável definida entre chaves tem um âmbito limitado a essas chaves: não é acessível fora delas. Os resultados acima mostram que este não é o caso no PHP. A variável $i definida na linha 5 dentro das chaves é a mesma que a utilizada nas linhas 4 e 8 fora delas.

3.3. Matrizes

3.3.1. Matrizes unidimensionais clássicas (exemplo_04)


<?php
 
// classic paintings
// initialization
$tab1 = array(0, 1, 2, 3, 4, 5);
 
// routes - 1
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
  print "tab1[$i]=$tab1[$i]\n";
 
// routes - 2
print "tab1 a " . count($tab1) . " éléments\n";
reset($tab1);
while (list($clé, $valeur) = each($tab1))
  print "tab1[$clé]=$valeur\n";
 
// add elements
$tab1[] = $i++;
$tab1[] = $i++;
 
// routes - 3
print "tab1 a " . count($tab1) . " éléments\n";
$i = 0;
foreach ($tab1 as $élément) {
  print "tab1[$i]=$élément\n";
  $i++;
}
 
// delete last item
array_pop($tab1);
 
// routes - 4
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
  print "tab1[$i]=$tab1[$i]\n";
 
// delete first element
array_shift($tab1);
 
// routes - 5
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
  print "tab1[$i]=$tab1[$i]\n";
 
// addition at end of table
array_push($tab1, -2);
 
// routes - 6
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
  print "tab1[$i]=$tab1[$i]\n";
 
// addition at the beginning of the table
array_unshift($tab1, -1);
 
// routes - 7
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
  print "tab1[$i]=$tab1[$i]\n";
?>

Os resultados:

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

Comentários

O programa acima demonstra operações para manipular uma matriz de valores. Existem duas notações para matrizes em PHP:

1
2
$tableau=array("un",2,"trois")
$contraires=array("petit"=>"grand", "beau"=>"laid", "cher"=>"bon marché")

A matriz 1 é chamada de matriz, e a matriz 2 é chamada de dicionário, onde os elementos são denotados como chave => valor. A notação $opposites["beautiful"] refere-se ao valor associado à chave "beautiful". Aqui, esse valor é a cadeia de caracteres "ugly". A matriz 1 é simplesmente uma variante do dicionário e poderia ser escrita como:

$tableau=array(0=>"un",1=>2,2=>"trois")

Assim, temos $array[2]="three". Em última análise, existem apenas dicionários. No caso de uma matriz clássica de n elementos, as chaves são os números inteiros no intervalo [0,n-1].

  • Linha 15: A função each($array) permite percorrer um dicionário. Em cada chamada, ela devolve um par (chave, valor) do dicionário.
  • Linha 14: A função reset($dictionary) define a função each para o primeiro par (chave, valor) no dicionário.
  • Linha 15: O ciclo while termina quando a função each devolve um par vazio no final do dicionário.
  • Linha 19: A notação $array[]=value adiciona o valor do elemento como o último elemento de $array.
  • linha 25: a matriz é percorrida utilizando um foreach. Esta sintaxe permite percorrer um dicionário e, portanto, uma matriz, utilizando duas sintaxes:
foreach($dictionnaire as $clé=>$valeur)
foreach($tableau as $valeur)

A primeira sintaxe devolve um par (chave, valor) em cada iteração, enquanto a segunda sintaxe devolve apenas o elemento valor do dicionário.

  • Linha 31: A função array_pop($array) remove o último elemento de $array
  • linha 39: a função array_shift($array) remove o primeiro elemento de $array
  • linha 47: a função array_push($array,value) adiciona value como o último elemento de $array
  • linha 39: a função array_unshift($array,value) adiciona value como o primeiro elemento de $array

3.3.2. O dicionário (example_05)


<?php
 
// dictionaries
$conjoints = array("Pierre" => "Gisèle", "Paul" => "Virginie", "Jacques" => "Lucette", "Jean" => "");
 
// routes - 1
print "Nombre d'éléments du dictionnaire : " . count($conjoints) . "\n";
reset($conjoints);
while (list($clé, $valeur) = each($conjoints))
  print "conjoints[$clé]=$valeur\n";
 
// dictionary sorting on key
ksort($conjoints);
 
// routes - 2
reset($conjoints);
while (list($clé, $valeur) = each($conjoints))
  print "conjoints[$clé]=$valeur\n";
 
// list of dictionary keys
$clés = array_keys($conjoints);
for ($i = 0; $i < count($clés); $i++)
  print "clés[$i]=$clés[$i]\n";
 
// list of dictionary values
$valeurs = array_values($conjoints);
for ($i = 0; $i < count($valeurs); $i++)
  print "valeurs[$i]=$valeurs[$i]\n";
 
// key search
existe($conjoints, "Jacques");
existe($conjoints, "Lucette");
existe($conjoints, "Jean");
 
// deleting a key-value
unset($conjoints["Jean"]);
print "Nombre d'éléments du dictionnaire : " . count($conjoints) . "\n";
foreach ($conjoints as $clé => $valeur) {
  print "conjoints[$clé]=$valeur\n";
}
 
// end
exit;
 
function existe($conjoints, $mari) {
  // checks whether the key $mari exists in the dictionary $conjoints
  if (isset($conjoints[$mari]))
    print "La clé [$mari] existe associée à la valeur [$conjoints[$mari]]\n";
  else
    print "La clé [$mari] n'existe pas\n";
}
 
?>

Os resultados:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Nombre d'éléments du dictionnaire : 4
conjoints[Pierre]=Gisèle
conjoints[Paul]=Virginie
conjoints[Jacques]=Lucette
conjoints[Jean]=
conjoints[Jacques]=Lucette
conjoints[Jean]=
conjoints[Paul]=Virginie
conjoints[Pierre]=Gisèle
clés[0]=Jacques
clés[1]=Jean
clés[2]=Paul
clés[3]=Pierre
valeurs[0]=Lucette
valeurs[1]=
valeurs[2]=Virginie
valeurs[3]=Gisèle
La clé [Jacques] existe associée à la valeur [Lucette]
La clé [Lucette] n'existe pas
La clé [Jean] existe associée à la valeur []
Nombre d'éléments du dictionnaire : 3
conjoints[Jacques]=Lucette
conjoints[Paul]=Virginie
conjoints[Pierre]=Gisèle

Comentários

O código acima aplica a um dicionário o que vimos anteriormente para uma matriz simples. Iremos comentar apenas as novas funcionalidades:

  • linha 13: a função ksort (ordenação por chave) ordena um dicionário na ordem natural das chaves.
  • linha 21: a função array_keys($dictionary) devolve a lista das chaves do dicionário como uma matriz
  • linha 26: a função array_values($dicionário) devolve a lista dos valores do dicionário como uma matriz
  • linha 47: a função isset($variável) retorna true se a $variável tiver sido definida, false caso contrário.
  • Linha 36: A função unset($variável) elimina a $variável.

3.3.3. Matrizes multidimensionais (exemplo_06)


<?php
 
// classic multidimensional tables
// initialization
$multi = array(array(0, 1, 2), array(10, 11, 12, 13), array(20, 21, 22, 23, 24));
// route
for ($i1 = 0; $i1 < count($multi); $i1++)
  for ($i2 = 0; $i2 < count($multi[$i1]); $i2++)
    print "multi[$i1][$i2]=" . $multi[$i1][$i2] . "\n";
// multidimensional dictionaries
// initialization
$multi = array("zéro" => array(0, 1, 2), "un" => array(10, 11, 12, 13), "deux" => array(20, 21, 22, 23, 24));
// route
foreach ($multi as $clé => $valeur)
  for ($i2 = 0; $i2 < count($valeur); $i2++)
    print "multi[$clé][$i2]=" . $multi[$clé][$i2] . "\n";
?>

Resultados:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
multi[0][0]=0
multi[0][1]=1
multi[0][2]=2
multi[1][0]=10
multi[1][1]=11
multi[1][2]=12
multi[1][3]=13
multi[2][0]=20
multi[2][1]=21
multi[2][2]=22
multi[2][3]=23
multi[2][4]=24
multi[zéro][0]=0
multi[zéro][1]=1
multi[zéro][2]=2
multi[un][0]=10
multi[un][1]=11
multi[un][2]=12
multi[un][3]=13
multi[deux][0]=20
multi[deux][1]=21
multi[deux][2]=22
multi[deux][3]=23
multi[deux][4]=24

Comentários

  • linha 5: os elementos da matriz $multi são, eles próprios, matrizes
  • linha 12: a matriz $multi torna-se um dicionário (chave, valor), em que cada valor é uma matriz

3.3.4. Ligações entre cadeias de caracteres e matrizes (exemplo_07)


<?php
 
// string to array
$chaine = "1:2:3:4";
$tab = explode(":", $chaine);
 
// parcours tableau
print "tab a " . count($tab) . " éléments\n";
for ($i = 0; $i < count($tab); $i++)
  print "tab[$i]=$tab[$i]\n";
 
// table to string
$chaine2 = implode(":", $tab);
print "chaine2=$chaine2\n";
 
// add an empty field
$chaine.=":";
print "chaîne=$chaine\n";
$tab = explode(":", $chaine);
 
// parcours tableau
print "tab a " . count($tab) . " éléments\n";
for ($i = 0; $i < count($tab); $i++)
  print "tab[$i]=$tab[$i]\n"; //// we now have 5 elements, the last being empty
 
// let's add another empty field
$chaine.=":";
print "chaîne=$chaine\n";
$tab = explode(":", $chaine);
 
// parcours tableau
print "tab a " . count($tab) . " éléments\n";
for ($i = 0; $i < count($tab); $i++)
  print "tab[$i]=$tab[$i]\n"; //// we now have 6 elements, the last two being empty
?>

Resultados:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
tab a 4 éléments
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
chaine2=1:2:3:4
chaîne=1:2:3:4:
tab a 5 éléments
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
tab[4]=
chaîne=1:2:3:4::
tab a 6 éléments
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
tab[4]=
tab[5]=

Comentários

  • Linha 5: A função explode($separator,$string) recupera os campos de $string separados por $separator. Assim, explode(":",$string) devolve os elementos de $string separados pela string ":" como uma matriz.
  • A função implode($separator,$array) realiza a operação oposta à função explode. Ela devolve uma cadeia de caracteres composta pelos elementos de $array separados por $separator.

3.4. Strings

3.4.1. Sintaxe (exemplo_08)


<?php
 
// string notation
$chaine1 = "un";
$chaine2 = 'un';
print "[$chaine1,$chaine2]\n";
?>

Resultados:

[un,un]

3.4.2. Comparação (exemplo_09)


<?php
 
// string comparison tests
compare("abcd", "abcd");
compare("", "");
compare("1", "");
exit;
 
function compare($chaine1, $chaine2) {
  // compare string1 and string2
  if ($chaine1 == $chaine2)
    print "[$chaine1] est égal à [$chaine2]\n";
  else
    print "[$chaine1] est différent de [$chaine2]\n";
}
 
?>

Resultados:

1
2
3
[abcd] est égal à [abcd]
[] est égal à []
[1] est différent de []

3.5. Expressões regulares (exemplo_10)


<?php
 
// regular expression in PHP
// retrieve the various fields of a string
 
// the model: a sequence of numbers surrounded by any characters
// you only want to retrieve the sequence of digits
$modèle = "/(\d+)/";
// the chain is compared with the
compare($modèle, "xyz1234abcd");
compare($modèle, "12 34");
compare($modèle, "abcd");
 
// the model: a sequence of numbers surrounded by any characters
// we want the sequence of numbers and the fields that follow and precede them
$modèle = "/^(.*?)(\d+)(.*?)$/";
// the chain is compared with the
compare($modèle, "xyz1234abcd");
compare($modèle, "12 34");
compare($modèle, "abcd");
 
// the template - a date in dd/mm/yy format
$modèle = "/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/";
compare($modèle, "10/05/97");
compare($modèle, "  04/04/01  ");
compare($modèle, "5/1/01");
 
// the model - a decimal number
$modèle = "/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/";
compare($modèle, "187.8");
compare($modèle, "-0.6");
compare($modèle, "4");
compare($modèle, ".6");
compare($modèle, "4.");
compare($modèle, " + 4");
 
// end
exit;
 
// --------------------------------------------------------------------------
function compare($modèle, $chaîne) {
  // compares the $chaîne string with the $modèle model
  // the chain is compared with the model
  $correspond = preg_match($modèle, $chaîne, $champs);
  // displaying results
  print "\nRésultats($modèle,$chaîne)\n";
  if ($correspond) {
    for ($i = 0; $i < count($champs); $i++)
      print "champs[$i]=$champs[$i]\n";
  } else
    print "La chaîne [$chaîne] ne correspond pas au modèle [$modèle]\n";
}
?>

Resultados:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
Résultats(/(\d+)/,xyz1234abcd)
champs[0]=1234
champs[1]=1234

Résultats(/(\d+)/,12 34)
champs[0]=12
champs[1]=12

Résultats(/(\d+)/,abcd)
La chaîne [abcd] ne correspond pas au modèle [/(\d+)/]

Résultats(/^(.*?)(\d+)(.*?)$/,xyz1234abcd)
champs[0]=xyz1234abcd
champs[1]=xyz
champs[2]=1234
champs[3]=abcd

Résultats(/^(.*?)(\d+)(.*?)$/,12 34)
champs[0]=12 34
champs[1]=
champs[2]=12
champs[3]= 34

Résultats(/^(.*?)(\d+)(.*?)$/,abcd)
La chaîne [abcd] ne correspond pas au modèle [/^(.*?)(\d+)(.*?)$/]

Résultats(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,10/05/97)
champs[0]=10/05/97
champs[1]=10
champs[2]=05
champs[3]=97

Résultats(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,  04/04/01  )
champs[0]=  04/04/01  
champs[1]=04
champs[2]=04
champs[3]=01

Résultats(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,5/1/01)
La chaîne [5/1/01] ne correspond pas au modèle [/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/]

Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,187.8)
champs[0]=187.8
champs[1]=
champs[2]=187.8

Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,-0.6)
champs[0]=-0.6
champs[1]=-
champs[2]=0.6

Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,4)
champs[0]=4
champs[1]=
champs[2]=4

Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,.6)
champs[0]=.6
champs[1]=
champs[2]=.6

Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,4.)
champs[0]=4.
champs[1]=
champs[2]=4.

Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/, + 4)
champs[0]= + 4
champs[1]=+
champs[2]=4

Comentários

  • Linhas 3-4: Aqui, usamos expressões regulares para extrair os vários campos de uma string. As expressões regulares permitem-nos superar as limitações da função implode. O princípio consiste em comparar uma string com outra string, chamada padrão, utilizando a função preg_match:

$correspond = preg_match($modèle, $chaîne, $champs);

A função preg_match devolve um valor booleano que indica se o padrão pode ser encontrado na cadeia de caracteres. Se for o caso, $fields[0] representa a subcadeia que corresponde ao padrão. Além disso, se o padrão contiver subpadrões entre parênteses, $champs[1] é a parte de $string que corresponde ao primeiro subpadrão, $champs[2] é a parte de $string que corresponde ao segundo subpadrão, e assim por diante...

Considere o primeiro exemplo. O padrão é definido na linha 8: denota uma sequência de um ou mais (+) dígitos (\d) localizados em qualquer parte de uma string. Além disso, o padrão define um subpadrão entre parênteses.

  • Linha 10: o padrão /(\d+)/ (uma sequência de um ou mais dígitos em qualquer lugar da string) é comparado com a string "xyz1234abcd". Vemos que a substring 1234 corresponde ao padrão. Portanto, $fields[0] será igual a "1234". Além disso, o padrão tem subpadrões entre parênteses. Teremos $champs[1]="1234".
  • Linha 11: O padrão /(\d+)/ é comparado com a cadeia "12 34". Verificamos que as subcadeias 12 e 34 correspondem ao padrão. A comparação pára na primeira subcadeia que corresponde ao padrão. Portanto, $champs[0] = 12 e $champs[1] = 12.
  • Linha 12: O padrão /(\d+)/ é comparado com a cadeia "abcd". Não é encontrada nenhuma correspondência.

Vamos explicar os padrões utilizados no resto do código:


$modèle = "/^(.*?)(\d+)(.*?)$/";

início da cadeia (^), depois 0 ou mais (*) caracteres arbitrários (.), depois 1 ou mais (+) dígitos, depois novamente 0 ou mais (*) caracteres arbitrários (.). O padrão (.*) denota 0 ou mais caracteres arbitrários. Um padrão deste tipo corresponderá a qualquer cadeia. Assim, o padrão /^(.*)(\d+)(.*)$/ nunca será encontrado porque o primeiro subpadrão (.*) consumirá toda a cadeia. O padrão (.*?)(\d+) denota 0 ou mais caracteres arbitrários até ao próximo subpadrão (?), neste caso \d+. Portanto, os dígitos já não são capturados pelo padrão (.*). O padrão acima corresponde, assim, a [início da cadeia (^), uma sequência de quaisquer caracteres (.*?), uma sequência de um ou mais dígitos (\d+), uma sequência de quaisquer caracteres (.*?), fim da cadeia ($)].


$modèle = "/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/";

corresponde a [início da cadeia (^), 2 dígitos (\d\d), o caractere / (\/), 2 dígitos, /, 2 dígitos, uma sequência de 0 ou mais espaços (\s*), fim da cadeia ($)]


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

[início da cadeia (^), 0 ou mais espaços (\s*), um sinal + ou - [+|-] que ocorre 0 ou 1 vez (?), uma sequência de 0 ou mais espaços (\s*), 1 ou mais dígitos seguidos de um ponto decimal seguido de zero ou mais dígitos (\d+\.\d*) ou (|) um ponto decimal (\.) seguido de um ou mais dígitos (\d+) ou (|) um ou mais dígitos (\d+), uma sequência de 0 ou mais espaços (\s*)].

3.6. Modo de passagem de parâmetros de função (exemplo_11)


<?php
 
// parameter step mode
 
function f(&$i, $j) {
  // $i will be obtained by reference
  // $j will be obtained by value
  $i++;
  $j++;
  print "f[i,j]=[$i,$j]\n";
}
 
// ----------------------------------------tests
$i = 0;
$j = 0;
// $i and $j passed by values
f($i, $j);
print "test[i,j]=[$i,$j]\n";
?>

Resultados:

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

Comentários

O código acima demonstra as duas formas de passar parâmetros a uma função. Consideremos o seguinte exemplo:

1
2
3
4
5
6
7
function f(&$a,$b){
…
}

// main program
$i=10; $j=20;
f($i,$j);
  • linha 1: define os parâmetros formais $a e $b da função f. Esta função manipula estes dois parâmetros formais e devolve um resultado.
  • linha 7: chama a função f com dois parâmetros reais $i e $j. As ligações entre os parâmetros formais ($a, $b) e os parâmetros reais ($i, $j) são definidas pela linha 7
  • &$a: o símbolo & indica que o parâmetro formal $a assumirá o valor do endereço do parâmetro real $i. Por outras palavras, $a e $i são duas referências à mesma localização de memória. Manipular o parâmetro formal $a é equivalente a manipular o parâmetro real $i. Isto é demonstrado pela execução do código. Este método de passagem é adequado para parâmetros de saída e grandes conjuntos de dados, tais como matrizes e dicionários. Este método de passagem é chamado de passagem por referência.
  • $b: O parâmetro formal $b assumirá o valor do parâmetro real $j. Trata-se de passagem por valor. Os parâmetros formais e reais são duas variáveis diferentes. Manipular o parâmetro formal $b não tem efeito sobre o parâmetro real $j. Isto é demonstrado pela execução do código. Este modo de passagem é adequado para parâmetros de entrada.
  • Considere a função swap, que recebe dois parâmetros formais $a e $b. A função troca os valores destes dois parâmetros. Assim, durante uma chamada a swap($i,$j), o código de chamada espera que os valores dos dois parâmetros reais sejam trocados. Estes são, portanto, parâmetros de saída (são modificados). Escreveremos, portanto:
function échange(&$a,&$b){....}

3.7. Resultados devolvidos por uma função (exemplo_12)


<?php
 
// results rendered by a function
// a function can return several values in an array
list($res1, $res2, $res3) = f1(10);
print "[$res1,$res2,$res3]\n";
$res = f1(10);
for ($i = 0; $i < count($res); $i++)
  print "res[$i]=$res[$i]\n";
 
// a function can render a pseudo-object
$res = f2(10);
print "[$res->res1,$res->res2,$res->res3]\n";
 
// end
exit;
 
// function f1
function f1($valeur) {
  // returns an array ($valeur+1,$aleur+2,$baleur+3)
  return array($valeur + 1, $valeur + 2, $valeur + 3);
}
 
// function f2
function f2($valeur) {
  // renders a pseudo-object ($valeur+1,$aleur+2,$baleur+3)
  $res->res1 = $valeur + 1;
  ;
  $res->res2 = $valeur + 2;
  $res->res3 = $valeur + 3;
  // makes the object
  return $res;
}
 
?>

Resultados

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

Comentários

  • O programa anterior mostra que uma função PHP pode devolver um conjunto de resultados em vez de um único, na forma de uma matriz ou de um objeto. O conceito de objeto é explicado com mais detalhe abaixo
  • linhas 19–22: a função f1 devolve vários valores na forma de um array
  • linhas 25–33: a função f2 retorna vários valores na forma de um objeto

3.8. Ficheiros de texto (exemplo_13)


<?php
 
// sequential operation of a text file
// this is a set of lines of the form login:pwd:uid:gid:infos:dir:shell
// each line is put into a dictionary in the form login => uid:gid:infos:dir:shell
 
// set the file name
$INFOS = "infos.txt";
 
// we open it in creation
if (!$fic = fopen($INFOS, "w")) {
  print "Erreur d'ouverture du fichier $INFOS en écriture\n";
  exit;
}
 
// generate arbitrary content
for ($i = 0; $i < 100; $i++)
  fputs($fic, "login$i:pwd$i:uid$i:gid$i:infos$i:dir$i:shell$i\n");
// close the file
fclose($fic);
 
// we use it - fgets keeps the end-of-line marker
// this prevents the retrieval of an empty string when reading a blank line
// we open it in creation
if (!$fic = fopen($INFOS, "r")) {
  print "Erreur d'ouverture du fichier $INFOS en lecture\n";
  exit;
}
while ($ligne = fgets($fic, 1000)) {
  // delete the end-of-line marker if it exists
  $ligne = cutNewLineChar($ligne);
  // put the line in a table
  $infos = explode(":", $ligne);
  // retrieve login
  $login = array_shift($infos);
  // we neglect the pwd
  array_shift($infos);
  // create a dictionary entry
  $dico[$login] = $infos;
}
// close it
fclose($fic);
 
// using the dictionary
afficheInfos($dico, "login10");
afficheInfos($dico, "X");
 
// end
exit;
 
// --------------------------------------------------------------------------
function afficheInfos($dico, $clé) {
  // displays the value associated with key in the $dico dictionary if it exists
  if (isset($dico[$clé])) {
    // value exists - is it a painting?
    $valeur = $dico[$clé];
    if (is_array($valeur)) {
      print "[$clé," . join(":", $valeur) . "]\n";
    } else {
      // $valeur is not an array
      print "[$clé,$valeur]\n";
    }
  } else {
    // $clé is not a key in the $dico dictionary
    print "la clé [$clé] n'existe pas\n";
  }
}
 
// --------------------------------------------------------------------------
function cutNewLinechar($ligne) {
  // delete the end-of-line mark from $ligne if it exists
  $L = strlen($ligne);  // // line length
  while (substr($ligne, $L - 1, 1) == "\n" or substr($ligne, $L - 1, 1) == "\r") {
    $ligne = substr($ligne, 0, $L - 1);
    $L--;
  }
  // end
  return($ligne);
}
 
?>

O ficheiro 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

Os resultados:

1
2
[login10,uid10:gid10:infos10:dir10:shell10]
la clé [X] n'existe pas

Comentários

  • Linha 11: fopen(filename, "w") abre o ficheiro filename para gravação (w = write). Se o ficheiro não existir, é criado. Se existir, o seu conteúdo é apagado. Se a criação falhar, fopen devolve false. Na instrução if (!$fic = fopen($INFOS, "w")) {…}, há duas operações sucessivas: 1) $fic=fopen(..) 2) if( ! $fic) {...}
  • Linha 18: fputs($fic,$string) escreve string no ficheiro $fic.
  • Linha 20: fclose($fic) fecha o ficheiro $fic.
  • Linha 25: fopen(filename, "r") abre o ficheiro filename para leitura (r=read). Se a abertura falhar (o ficheiro não existe), fopen retorna o valor false.
  • Linha 29: fgets($fic,1000) lê a linha seguinte do ficheiro, limitada a 1000 caracteres. Na operação while ($line = fgets($fic, 1000)) {…}, existem duas operações sucessivas: 1) $line = fgets(...) 2) while ( ! $line). Após a leitura do último caractere do ficheiro, a função fgets devolve uma cadeia de caracteres vazia e o ciclo while termina.
  • Linha 31: A função fgets lê uma linha de texto, incluindo o caractere de nova linha. A função cutNewLineChar nas linhas 70–79 remove qualquer caractere de nova linha.
  • Linha 72: a função strlen($string) devolve o número de caracteres em $string.
  • Linha 73: A função substr($line, $position, $size) devolve $size caracteres de $line, a partir do caractere #$position, sendo que o primeiro caractere é o #0. Em máquinas Windows, o marcador de fim de linha é "\r\n". Em máquinas Unix, é a cadeia "\n".
  • Linha 35: a função array_shift($array) remove o primeiro elemento de $array e devolve-o como resultado.
  • Linha 37: a função array_shift($array) é utilizada, mas o seu resultado é ignorado
  • Linha 57: A função is_array($variable) retorna true se $variable for uma matriz, false caso contrário.
  • Linha 58: A função join faz o mesmo que a função implode que vimos anteriormente
https://stahe.github.io
Este curso-tutorial escrito por Serge Tahé é disponibilizado ao público de acordo com os termos da Licença Creative Commons Atribuição – Sem uso comercial – Partilha nas mesmas condições 3.0 não adaptada.