Cum sa extragi parametrii unei functii in PHP?

O problema destul de interesanta atunci cand vine vorba de interpretarea codului, este analiza parametrilor. In acest articol voi prezenta o modalitate, simpla, dar eficienta de a interpreta parametrii unei functii, clase initializate samd. Pentru a usura mai mult subiectul tratatat, am decis ca toti parametrii trebuie sa fie de tipul array(), de dimensiune nedefinita iar numarul acestora sa fie nelimitat.

Problemele intampinate

Evident, ca orice idee, aceasta poate avea „buguri”. Cel mai usor ar fi dupa unii sa rezolvam problema folosind o expresie regulata, sau un split dupa „,” samd. Nici una dintre aceste probleme nu poate fi abordata eficient pentru ca in primul caz, expresia regulata nu poate fi generalizata, iar in al doilea caz (problema care se aplica si la primul), virgula poate fi prezenta si in interiorul array-ului (daca acesta este unidimensional).

Abordarea corecta

Ideea care in aceasta situatie mi se pare cea mai eficienta, atat din punctul de vedere al complexitatii – O(n), cat si din punctul de de vedere al dificultatii de implementare este o abordare ce deriva dintr-un algoritm destul de simplu – evaluarea unei expresii in vederea corectitudinii ei.

Una din abordarile acestei probleme presupune numararea parantezelor deschise (adunarea lor) si eliminarea celor inchise (scaderea lor) atat timp cat acest lucru este posibil (valoarea respectiva depaseste zero). Modificand putin problema, vom avea urmatoarea abordare :

	function computeParams($params)
	{
		//O(n)
		$np   = array(); $open = 0; $content = ''; $i = 0; $n = strlen($params); $k = 0;
		while($i < $n) //cat timp indicele nu a depasit lungimea sirului
		{
                        //daca avem nevoie de un nou parametru, il cautam
			if($open <= 0 && stripos($params,'array(', $i) !== FALSE)
			{
                                //daca exista mutam indicele pe el, il initializam
				$i = stripos($params,'array(', $i)+5;
				$np[$k] = array();
				$open = 1; 
				$content = 'array(';
			}
			else //in caz contrar suntem intr-un indice ce incercam sa-l parcurgem
			{ 
				$content .= $params{$i}; // adaugam caracterul curent la parametrul actual(continutul acestuia)
				if($params{$i}=='(') $open++; // numaram parentezele deschise
				if($params{$i}==')') $open--; // scadem parantezele inchise 
				if($open <= 0) $np[$k++] = trim($content); // daca valoarea parantezelor este mai mica ca zero am terminat parametrul
			}			 
			$i++;
		}
		return $np;
	}

Ok, avem parametrii acum, intr-un array de forma $ARR[x] = tot continutul parametrului al x-lea. (indicele incepand de la zero).
Urmeaza interpretarea acestor parametri. Spre exemplu dorim sa avem $ARR[x][setare] = valoare. Din nou, pentru a simplifica codul, am decis ca toate valorile parametrilor sa fie de forma cheie => valoare. Vom avea nevoie de o noua functie.

	function computeParamsArgs($args)
	{
		//O(k + q) 
                //incercam sa gasim toti parametrii, folosind  expresia regulata de mai jos
		preg_match_all('/([\'"].*?[\'"]).*=>.*(array\(.*?\)|[\'"].*?[\'"]|true|false|0-9*)/is', $args, $args); //sizeof() = q
	 	
		$keys = $args[1]; //k = sizeof($keys), avem cheile parametrilor
		$vals = $args[2]; // avem valorile parametrilor
		$args = array();
		
                //parcurgem fiecare cheie 
		for($i = 0; $i < sizeof($keys); $i++)
		   if(isset($vals[$i])) //daca o gasim valoarea cheii respective	   			     
			   $args[trim($keys[$i],'\'" ')] = trim($vals[$i],'\'" '); // o parsam (fara ghilimele) si o adaugam intr-un vector
		return $args;
	}

Evident, abordarea de mai sus se refera doar la primul nivel al array-ului. Nu trebuie sa uitam faptul ca aceasta functie va fi folosita doar pentru a parsa unul dintre cei n parametrii extrasi. Interesanta poate fi si modificarea functiei, facand-o recursiva pentru a parsa un array in adancime. Oricum, editarea ei e o chestie de vreo 2-5 randuri, deci poate fi usor rezolvata daca esti interesat.

Ok, dar ce ne facem daca dorim sa restauram codul in forma lui originala? Pentru asta vom avea nevoie de o alta functie ce se va folosi de vectorul nostru unidimensional pentru a restaura parametrii intr-un singur sir.

    	private function restoreParamsArgs($args)
	{
		//O(2n)
		$params = 'array(';
						  
		foreach($args as $key => $value) //luam fiecare setare cu cheie/valoare 
		{
			if(strtolower(substr($value, 0, 6))!='array(' && strpos($value,'\'') !== false) //daca nu e un array valoarea
				$value = '\''.str_replace('\'', '\\\'', $value[$i]).'\''; //ii adaugam ghilimele, avand grija sa le parsam pe cele interioare
			$args[$key] = '\''.$key.'\' => '.$value; //adaugam argumentele intr-un vector sub forma de sir de caractere
		}
		$params .= implode(',', array_values($args)); /lipim argumentele create
		$params.= ')';
		return $params;
	}

Abordarea este simpla, doar ca si aceasta va necesita putina atentie din partea dumneavoastra in cazul in care veti dori sa parcurgeti array-urile in adancime pana la ultimul nivel.

Cum punem totul in miscare?

Simplu!!!

$params = "array('cheie' => 'valoare', 'cheie2' => 1000, 'cheie3' => array(valoare)), array('cheie2' => TRUE, 'cheie3' => FALSE)"; 
$ARR = computeParams($params); //construim parametrii (parsam)

foreach($ARR as $key => $value) //interpretam cheile si valorile din parametrii
    $ARR[$key] = computeParamsArgs($value);
print_r($ARR);
$ARR[0]['cheie'] = 'valoare_modificata'; //modificam o valoare

foreach($ARR as $key => $value) //restauram
    $ARR[$key] = restoreParams($value);
$params = implode(','$ARR);//construim textul initial avand un parametru modificat
echo $params;

Aceasta idee poate fi dusa la un nivel foarte mare, ajungand sa interpreteze adevarate blocuri de cod in acest mod. Totul tine de imaginatia ta. Enjoy! 🙂