utf8 - recorrer string php
¿Cómo obtener un nombre de variable como una cadena en PHP? (22)
¿Por qué no solo construyes una función simple y LO DICEN?
/**
* Prints out $obj for debug
*
* @param any_type $obj
* @param (string) $title
*/
function print_all( $obj, $title = false )
{
print "/n<div style=/"font-family:Arial;/">/n";
if( $title ) print "<div style=/"background-color:red; color:white; font-size:16px; font-weight:bold; margin:0; padding:10px; text-align:center;/">$title</div>/n";
print "<pre style=/"background-color:yellow; border:2px solid red; color:black; margin:0; padding:10px;/">/n/n";
var_export( $obj );
print "/n/n</pre>/n</div>/n";
}
print_all( $aUser, ''$aUser'' );
Digamos que tengo este código PHP:
$FooBar = "a string";
entonces necesito una función como esta:
print_var_name($FooBar);
que imprime:
FooBar
¿Alguna idea de cómo lograr esto? ¿Esto es posible en PHP?
¿Por qué tenemos que usar globales para obtener el nombre de la variable ... podemos usar simplemente como a continuación?
$variableName = "ajaxmint";
echo getVarName(''$variableName'');
function getVarName($name) {
return str_replace(''$'','''',$name);
}
¿Puede considerar cambiar su enfoque y usar un nombre variable de variable?
$var_name = "FooBar";
$$var_name = "a string";
entonces podrías simplemente
print($var_name);
Llegar
FooBar
Aquí está el enlace al manual de PHP sobre Variables variables
Adaptado de las respuestas anteriores para muchas variables, con buen rendimiento, solo una exploración de $ GLOBALS para muchos
function compact_assoc(&$v1=''__undefined__'', &$v2=''__undefined__'',&$v3=''__undefined__'',&$v4=''__undefined__'',&$v5=''__undefined__'',&$v6=''__undefined__'',&$v7=''__undefined__'',&$v8=''__undefined__'',&$v9=''__undefined__'',&$v10=''__undefined__'',&$v11=''__undefined__'',&$v12=''__undefined__'',&$v13=''__undefined__'',&$v14=''__undefined__'',&$v15=''__undefined__'',&$v16=''__undefined__'',&$v17=''__undefined__'',&$v18=''__undefined__'',&$v19=''__undefined__''
) {
$defined_vars=get_defined_vars();
$result=Array();
$reverse_key=Array();
$original_value=Array();
foreach( $defined_vars as $source_key => $source_value){
if($source_value===''__undefined__'') break;
$original_value[$source_key]=$$source_key;
$new_test_value="PREFIX".rand()."SUFIX";
$reverse_key[$new_test_value]=$source_key;
$$source_key=$new_test_value;
}
foreach($GLOBALS as $key => &$value){
if( is_string($value) && isset($reverse_key[$value]) ) {
$result[$key]=&$value;
}
}
foreach( $original_value as $source_key => $original_value){
$$source_key=$original_value;
}
return $result;
}
$a = ''A'';
$b = ''B'';
$c = ''999'';
$myArray=Array (''id''=>''id123'',''name''=>''Foo'');
print_r(compact_assoc($a,$b,$c,$myArray) );
//print
Array
(
[a] => A
[b] => B
[c] => 999
[myArray] => Array
(
[id] => id123
[name] => Foo
)
)
Aquí está mi solución basada en Jeremy Ruten
class DebugHelper {
function printVarNames($systemDefinedVars, $varNames) {
foreach ($systemDefinedVars as $var=>$value) {
if (in_array($var, $varNames )) {
var_dump($var);
var_dump($value);
}
}
}
}
usándolo
DebugHelper::printVarNames(
$systemDefinedVars = get_defined_vars(),
$varNames=array(''yourVar00'', ''yourVar01'')
);
Creo que quieres saber el nombre de la variable con su valor. Puede usar una matriz asociativa para lograr esto.
usar nombres de variables para las teclas de matriz:
$vars = array(''FooBar'' => ''a string'');
Cuando desee obtener nombres de variables, use array_keys($vars) , devolverá una matriz de esos nombres de variables que se usaron en su array $vars como sus claves.
Utilizo esta forma para obtener los nombres de columna de la tabla en mi clase de Base de Datos.
De hecho, tengo un caso de uso válido para esto.
Tengo una función cacheVariable ($ var) (ok, tengo un caché de función ($ key, $ value), pero me gustaría tener una función como se menciona).
El propósito es hacer:
$colour = ''blue'';
cacheVariable($colour);
...
// another session
...
$myColour = getCachedVariable(''colour'');
Lo he intentado con
function cacheVariable($variable) {
$key = ${$variable}; // This doesn''t help! It only gives ''variable''.
// do some caching using suitable backend such as apc, memcache or ramdisk
}
También he intentado con
function varName(&$var) {
$definedVariables = get_defined_vars();
$copyOfDefinedVariables = array();
foreach ($definedVariables as $variable=>$value) {
$copyOfDefinedVariables[$variable] = $value;
}
$oldVar = $var;
$var = !$var;
$difference = array_diff_assoc($definedVariables, $copyOfDefinedVariables);
$var = $oldVar;
return key(array_slice($difference, 0, 1, true));
}
Pero esto también falla ... :(
Claro, podría continuar haciendo caché (''color'', $ color), pero soy flojo, ya sabes ...;)
Entonces, lo que quiero es una función que obtiene el nombre ORIGINAL de una variable, ya que se pasó a una función. Dentro de la función no hay manera de que pueda saber eso, como parece. Pasar get_defined_vars () por referencia en el segundo ejemplo anterior me ayudó un tanto (gracias a Jean-Jacques Guegan por esa idea). La última función comenzó a funcionar, pero solo siguió devolviendo la variable local (''variable'', no ''color'').
Todavía no he intentado utilizar get_func_args () y get_func_arg (), $ {} - constructs y key () combinados, pero supongo que también fallarán.
Desde php.net
@Alexandre - solución corta
<?php
function vname(&$var, $scope=0)
{
$old = $var;
if (($key = array_search($var = ''unique''.rand().''value'', !$scope ? $GLOBALS : $scope)) && $var = $old) return $key;
}
?>
@Lucas - uso
<?php
//1. Use of a variable contained in the global scope (default):
$my_global_variable = "My global string.";
echo vname($my_global_variable); // Outputs: my_global_variable
//2. Use of a local variable:
function my_local_func()
{
$my_local_variable = "My local string.";
return vname($my_local_variable, get_defined_vars());
}
echo my_local_func(); // Outputs: my_local_variable
//3. Use of an object property:
class myclass
{
public function __constructor()
{
$this->my_object_property = "My object property string.";
}
}
$obj = new myclass;
echo vname($obj->my_object_property, $obj); // Outputs: my_object_property
?>
Estaba buscando esto, pero solo decidí ingresar el nombre, generalmente tengo el nombre en el portapapeles.
function VarTest($my_var,$my_var_name){
echo ''$''.$my_var_name.'': ''.$my_var.''<br />'';
}
$fruit=''apple'';
VarTest($fruit,''fruit'');
Esto es exactamente lo que quiere: es una función lista para usar de "copiar y soltar" que repite el nombre de una var dada:
function print_var_name(){
// read backtrace
$bt = debug_backtrace();
// read file
$file = file($bt[0][''file'']);
// select exact debug($varname) line
$src = $file[$bt[0][''line'']-1];
// search pattern
$pat = ''#(.*)print_var_name *?/( *?/$(.*) *?/)(.*)#i'';
// extract $varname from match no 2
$var = preg_replace($pat, ''$2'', $src);
// print to browser
echo trim($var);
}
USO: print_var_name ($ FooBar)
IMPRESIÓN: FooBar
SUGERENCIA Esto no es a prueba de balas: si la función se llama más de una vez (en una sola línea) ¡fallará!
Hice una función de inspección por razones de depuración. Es como print_r () con esteroides, muy parecido a Krumo pero un poco más efectivo en objetos. Quería agregar la detección del nombre var y salí con esto, inspirado por la publicación de Nick Presta en esta página. Detecta cualquier expresión pasada como argumento, no solo nombres de variables.
Esta es solo la función de envoltura que detecta la expresión pasada. Funciona en la mayoría de los casos. No funcionará si llama a la función más de una vez en la misma línea de código.
Esto funciona bien: morir ( inspeccionar ( $ this-> getUser () -> hasCredential ("delete") ) );
inspeccionar () es la función que detectará la expresión pasada.
Obtenemos: $ this-> getUser () -> hasCredential ("delete")
function inspect($label, $value = "__undefin_e_d__")
{
if($value == "__undefin_e_d__") {
/* The first argument is not the label but the
variable to inspect itself, so we need a label.
Let''s try to find out it''s name by peeking at
the source code.
*/
/* The reason for using an exotic string like
"__undefin_e_d__" instead of NULL here is that
inspected variables can also be NULL and I want
to inspect them anyway.
*/
$value = $label;
$bt = debug_backtrace();
$src = file($bt[0]["file"]);
$line = $src[ $bt[0][''line''] - 1 ];
// let''s match the function call and the last closing bracket
preg_match( "#inspect/((.+)/)#", $line, $match );
/* let''s count brackets to see how many of them actually belongs
to the var name
Eg: die(inspect($this->getUser()->hasCredential("delete")));
We want: $this->getUser()->hasCredential("delete")
*/
$max = strlen($match[1]);
$varname = "";
$c = 0;
for($i = 0; $i < $max; $i++){
if( $match[1]{$i} == "(" ) $c++;
elseif( $match[1]{$i} == ")" ) $c--;
if($c < 0) break;
$varname .= $match[1]{$i};
}
$label = $varname;
}
// $label now holds the name of the passed variable ($ included)
// Eg: inspect($hello)
// => $label = "$hello"
// or the whole expression evaluated
// Eg: inspect($this->getUser()->hasCredential("delete"))
// => $label = "$this->getUser()->hasCredential(/"delete/")"
// now the actual function call to the inspector method,
// passing the var name as the label:
// return dInspect::dump($label, $val);
// UPDATE: I commented this line because people got confused about
// the dInspect class, wich has nothing to do with the issue here.
echo("The label is: ".$label);
echo("The value is: ".$value);
}
Aquí hay un ejemplo de la función de inspector (y mi clase dInspect) en acción:
Los textos están en español en esa página, pero el código es conciso y realmente fácil de entender.
Lucas en PHP.net proporcionó una forma confiable de verificar si existe una variable. En su ejemplo, itera a través de una copia de la matriz de variables globales (o una matriz de ámbito) de variables, cambia el valor a un valor generado aleatoriamente y verifica el valor generado en la matriz copiada.
function variable_name( &$var, $scope=false, $prefix=''UNIQUE'', $suffix=''VARIABLE'' ){
if($scope) {
$vals = $scope;
} else {
$vals = $GLOBALS;
}
$old = $var;
$var = $new = $prefix.rand().$suffix;
$vname = FALSE;
foreach($vals as $key => $val) {
if($val === $new) $vname = $key;
}
$var = $old;
return $vname;
}
Entonces intenta:
$a = ''asdf'';
$b = ''asdf'';
$c = FALSE;
$d = FALSE;
echo variable_name($a); // a
echo variable_name($b); // b
echo variable_name($c); // c
echo variable_name($d); // d
Asegúrese de revisar su publicación en PHP.net: http://php.net/manual/en/language.variables.php
Muchas respuestas cuestionan la utilidad de esto. Sin embargo, obtener una referencia para una variable puede ser muy útil. Especialmente en casos con objetos y $ this . Mi solución funciona con objetos y también como objetos definidos por la propiedad:
function getReference(&$var)
{
if(is_object($var))
$var->___uniqid = uniqid();
else
$var = serialize($var);
$name = getReference_traverse($var,$GLOBALS);
if(is_object($var))
unset($var->___uniqid);
else
$var = unserialize($var);
return "/${$name}";
}
function getReference_traverse(&$var,$arr)
{
if($name = array_search($var,$arr,true))
return "{$name}";
foreach($arr as $key=>$value)
if(is_object($value))
if($name = getReference_traverse($var,get_object_vars($value)))
return "{$key}->{$name}";
}
Ejemplo para lo anterior:
class A
{
public function whatIs()
{
echo getReference($this);
}
}
$B = 12;
$C = 12;
$D = new A;
echo getReference($B)."<br/>"; //$B
echo getReference($C)."<br/>"; //$C
$D->whatIs(); //$D
Nadie parece haber mencionado las razones fundamentales por las cuales esto es a) difícil y b) imprudente:
- Una "variable" es solo un símbolo que apunta a otra cosa. En PHP, apunta internamente a algo llamado "zval", que en realidad se puede usar para múltiples variables simultáneamente, ya sea porque tienen el mismo valor (PHP implementa algo llamado "copiar-en-escribir" para que
$foo = $barno necesita asignar memoria extra directamente) o porque han sido asignados (o pasados a una función) por referencia (ej.$foo =& $bar). Entonces un zval no tiene nombre. - Cuando pasa un parámetro a una función, está creando una nueva variable (incluso si es una referencia). Podrías pasar algo anónimo, como
"hello", pero una vez dentro de tu función, es la variable que elijas. Esto es bastante fundamental para la separación del código: si una función dependiera de lo que solía llamarse una variable, sería más como una funcióngotoque una función propiamente separada. - Las variables globales generalmente se consideran una mala idea. Muchos de los ejemplos aquí suponen que la variable que desea "reflejar" se puede encontrar en
$GLOBALS, pero esto solo será cierto si ha estructurado mal su código y las variables no tienen un alcance para alguna función u objeto. - Los nombres de variables están ahí para ayudar a los programadores a leer su código. Cambiar el nombre de las variables para que se adapte mejor a su propósito es una práctica de refactorización muy común, y el punto es que no hace ninguna diferencia.
Ahora, entiendo el deseo de depuración (aunque algunos de los usos propuestos van más allá), pero como solución generalizada no es tan útil como podría pensar: si su función de depuración dice que su variable se llama "$ file" ", esa podría ser cualquiera de las docenas de variables" $ file "en su código, o una variable que ha llamado" $ filename "pero que está pasando a una función cuyo parámetro se llama" $ file ".
Una información mucho más útil es en qué parte de su código se invocó la función de depuración. Como puede encontrarlo rápidamente en su editor, puede ver qué variable está produciendo para usted e incluso puede pasar expresiones completas en una sola vez (por ejemplo, debug(''$foo + $bar = '' . ($foo + $bar)) ).
Para eso, puedes usar este fragmento en la parte superior de tu función de depuración:
$backtrace = debug_backtrace();
echo ''# Debug function called from '' . $backtrace[0][''file''] . '' at line '' . $backtrace[0][''line''];
No podía pensar en una manera de hacer esto de manera eficiente tampoco, pero se me ocurrió esto. Funciona, para los usos limitados a continuación.
encogimiento de hombros
<?php
function varName( $v ) {
$trace = debug_backtrace();
$vLine = file( __FILE__ );
$fLine = $vLine[ $trace[0][''line''] - 1 ];
preg_match( "#//$(/w+)#", $fLine, $match );
print_r( $match );
}
$foo = "knight";
$bar = array( 1, 2, 3 );
$baz = 12345;
varName( $foo );
varName( $bar );
varName( $baz );
?>
// Returns
Array
(
[0] => $foo
[1] => foo
)
Array
(
[0] => $bar
[1] => bar
)
Array
(
[0] => $baz
[1] => baz
)
Funciona en función de la línea que llamó a la función, donde encuentra el argumento que pasó. Supongo que podría expandirse para que funcione con múltiples argumentos pero, como han dicho otros, si pudiera explicar mejor la situación, probablemente otra solución trabaja mejor.
Puede usar get_defined_vars() para encontrar el nombre de una variable que tenga el mismo valor que la que está tratando de encontrar. Obviamente, esto no siempre funcionará, ya que las diferentes variables a menudo tienen los mismos valores, pero es la única forma en que se me ocurre hacer esto.
Editar: get_defined_vars () no parece funcionar correctamente, devuelve ''var'' porque $ var se usa en la función misma. $ GLOBALS parece funcionar, así que lo cambié a eso.
function print_var_name($var) {
foreach($GLOBALS as $var_name => $value) {
if ($value === $var) {
return $var_name;
}
}
return false;
}
Editar: para que quede claro, no hay una buena manera de hacerlo en PHP, lo cual es probablemente porque no debería tener que hacerlo. Probablemente haya mejores formas de hacer lo que intentas hacer.
Puede usar compact () para lograr esto.
$FooBar = "a string";
$newArray = compact(''FooBar'');
Esto crearía una matriz asociativa con el nombre de la variable como clave. Luego puede recorrer el conjunto utilizando el nombre de la tecla donde lo necesitó.
foreach($newarray as $key => $value) {
echo $key;
}
Realmente no veo el caso de uso ... Si escribe print_var_name ($ foobar) ¿qué es tan difícil (y diferente) sobre escribir print ("foobar")?
Porque incluso si tuviera que usar esto en una función, obtendría el nombre local de la variable ...
En cualquier caso, aquí está el manual de reflexión en caso de que haya algo que necesite allí.
Se puede considerar rápido y sucio, pero mi preferencia personal es usar una función / método como este:
public function getVarName($var) {
$tmp = array($var => '''');
$keys = array_keys($tmp);
return trim($keys[0]);
}
Básicamente, solo crea una matriz asociativa que contiene un elemento nulo / vacío, utilizando como clave la variable para la que desea el nombre.
luego obtenemos el valor de esa clave usando array_keys y lo devolvemos.
Obviamente, esto se complica rápidamente y no sería deseable en un entorno de producción, pero funciona para el problema presentado.
Si la variable es intercambiable, debe tener lógica en alguna parte que determine qué variable se usa. Todo lo que necesita hacer es poner el nombre de la variable en $variable dentro de esa lógica mientras hace todo lo demás.
Creo que a todos nos cuesta entender por lo que necesitas esto. El código de muestra o una explicación de lo que estás tratando de hacer en realidad podrían ser de ayuda, pero sospecho que estás haciendo mucho, demasiado pensando en esto.
Tengo esto:
debug_echo(array(''$query''=>$query, ''$nrUsers''=>$nrUsers, ''$hdr''=>$hdr));
Yo preferiría esto:
debug_echo($query, $nrUsers, $hdr);
La función existente muestra un cuadro amarillo con un contorno rojo y muestra cada variable por nombre y valor. La solución de matriz funciona, pero es un poco complicada de escribir cuando es necesario.
Ese es mi caso de uso y sí, tiene que ver con la depuración. Estoy de acuerdo con quienes cuestionan su uso de lo contrario.
Use esto para separar las variables de usuario de globales para verificar variables en este momento.
function get_user_var_defined ()
{
return array_slice($GLOBALS,8,count($GLOBALS)-8);
}
function get_var_name ($var)
{
$vuser = get_user_var_defined();
foreach($vuser as $key=>$value)
{
if($var===$value) return $key ;
}
}