variables en php es una especie de contenedor de información que puede contener Varios tipos datos (texto, números, matrices, etc.). En general, las variables le permiten crear, almacenar, modificar y luego acceder rápidamente a la información especificada en ellas.
Cómo nombrar variables:
$var
$variable
$año1945
$_variable
Cómo no nombrar variables:
$1 - consta de solo un dígito
$1var: no puede comenzar un nombre de variable con un número
$/var: solo se permiten guiones bajos de caracteres adicionales _
$variable: la documentación de php permite el cirílico, pero no se recomienda
$variable: no se pueden usar espacios
A cada variable se le asigna un valor. El signo se utiliza para asignar un valor. =
(igual). Durante el procesamiento de scripts, el valor de una variable puede cambiar repetidamente dependiendo de varias condiciones.
$ciudad = "Moscú"; // a la variable $ciudad se le asignó la cadena (entre comillas) valor Moscú
$año = 1147; // ya la variable $año se le asignó el valor numérico 1147
?>
$nombre = "Alejandro";
$Nombre = "Alex";
echo "$nombre, $Nombre"; // imprime "Alexander, Alexey"
?>
// Así establecemos los valores de las variables
$nombre1 = "Alex";
$nombre2 = "Alejandro";
// Mostrar variables
echo $nombre2; // Salida: Alejandro
echo "nombre1 es $nombre1"; // nombre1 es Alexey
// Usando comillas simples producción
// nombre de variable, no valor
echo "nombre1 es $nombre1"; // salida: nombre1 es $nombre1
// puedes mostrar solo los valores de las variables
echo $nombre1; // Alexei
echo $nombre1,$nombre2; // AlexeyAlexander
echo $nombre1." ".$nombre2; // Alexei Alejandro
echo "$nombre1, $nombre2"; // Alexei, Alejandro
eco<<
varias líneas con sustitución de $variable.
FIN;
-$a(negación) Cambia el signo de $a.
$a + $b(suma) La suma de $a y $b.
$a - $b(resta) La diferencia entre $a y $b.
$a * $b(multiplicar) El producto de $a y $b.
$a / $b(división) El cociente de $a dividido por $b.
$a % $b(módulo) El resto entero de $a dividido por $b.
Considere ejemplos
$a = 2; // tenga en cuenta que en el caso de los números, no se ponen comillas
$b = 3; // tenga en cuenta que en el caso de los números, no se ponen comillas
$resultado = $a + $b; // agregar variables
echo $resultado; // imprime 5
$resultado = $b - $a; // agregar variables
echo $resultado; // imprime 1
Operaciones de incremento y decremento en PHP
Estas operaciones serán útiles principalmente en la construcción de ciclos, de lo que hablaremos un poco más adelante.
prefijo- operadores escritos ANTES de la variable ( --$a; ++$a). Devuelve el valor de la variable antes de los cambios.
Sufijo- operadores escritos después de la variable ( $a--; $a--). Devuelve el valor de una variable con cambios.
Incremento- aumentar el valor.
Decremento- valor decreciente.
++$a incremento de prefijo. Incrementa $a en uno y devuelve el valor de $a.
$a++ incremento de posfijo. Devuelve el valor de $a y luego incrementa $a en uno.
--$a prefijo decremento. Disminuye $a en uno y devuelve el valor de $a.
$a-- Decremento de posfijo. Devuelve el valor de $a y luego disminuye $a en uno.
eco "
eco"
eco"
eco"
Operaciones de asignación en PHP
Operador base parece =
. A primera vista, podría parecer que este es el operador igual. En realidad no lo es. En efecto, el operador de asignación significa que el operando de la izquierda obtiene el valor de la expresión de la derecha (es decir, se establece en el valor resultante). Operadores combinados- estos son operadores que le permiten usar los valores anteriores de las variables para operaciones posteriores (agregar a una variable de cadena (con texto) o agregar valores numéricos).
$a = ($b = 2) + 4; // resultado: $a se establece en 6, $b se establece en 2.
$a = 2;
$a += 3; // establece $a en 5, similar a $a = $a + 3;
$b = "Hola";
$b .= "¡Paz!"; // establece $b en "¡Hola mundo!" como $b = $b . "¡Allá!";
también hay operaciones de comparación Y rompecabezas, pero hablaremos de ellos en las próximas lecciones. ¡Intentaré no asustarte con una gran cantidad de información a la vez!)
hace 13 años
Un pequeño problema a tener en cuenta:
Si usted apagar RegisterGlobals y relacionados, luego use get_defined_vars(), puede ver algo como lo siguiente:
formación
[ GLOBALES ] => Matriz
[ GLOBALES ] => Matriz
* RECURSIÓN *
[_POST] => Matriz()
[_GET] => Matriz()
[_COOKIE] => Matriz()
[ _ARCHIVOS ] => Matriz()
)
[_POST] => Matriz()
[_GET] => Matriz()
[_COOKIE] => Matriz()
[ _ARCHIVOS ] => Matriz()
)
?>
Tenga en cuenta que $_SERVER no está allí. Parece que php solo carga el superglobal $_SERVER si se usa en alguna parte. Podría hacer esto:
imprimir"
" .htmlcaracteres especiales(print_r(get_defined_vars(), true )) . "" ;
".htmlcaracteres especiales (print_r ($_SERVER, verdadero))"." ;
Hace 6 años
Dado que get_defined_vars() solo obtiene las variables en el punto en el que llama a la función, existe una forma sencilla de definir las variables dentro del alcance actual.
// La parte superior de tu script php
$vars = get_defined_vars();
// Ahora haz tus cosas
$foo = "foo" ;
$barra = "barra" ;
// Obtener todas las variables definidas en el alcance actual
$vars = array_diff(get_defined_vars(), $vars);
eco "
" ;" ;
print_r($vars);
eco "
hace 15 años
Aquí hay una función que genera un informe de depuración para mostrarlo o enviarlo por correo electrónico
utilizando get_defined_vars. Excelente para obtener una instantánea detallada sin
confiando en la entrada del usuario.
función generarDebugReport ($método, $defined_vars, $email = "indefinido")(
// Función para crear un informe de depuración para mostrar o enviar por correo electrónico.
// Uso: generarDebugReport(método,get_defined_vars(),email);
// Donde el método es "navegador" o "correo electrónico".
// Crear una lista de ignorados para las claves devueltas por "get_defined_vars".
// Por ejemplo, HTTP_POST_VARS, HTTP_GET_VARS y otros son
// redundante (igual que _POST, _GET)
// También incluya vars que desea ignorar por razones de seguridad, es decir PHPSESSID.
$ignorelist =matriz("HTTP_POST_VARS" , "HTTP_GET_VARS" ,
"HTTP_COOKIE_VARS", "HTTP_SERVER_VARS",
"HTTP_ENV_VARS", "HTTP_SESSION_VARS",
"_ENV", "PHPSESSID", "SESS_DBUSER",
"SESS_DBPASS", "HTTP_COOKIE");
$marca de tiempo = fecha("m/d/y h:m:s" );
$mensaje = "Informe de depuración creado $marca de tiempo \n" ;
// Obtener el último error de SQL por si acaso, donde $enlace es el identificador del recurso
// para mysql_connect. Comente o modifique su base de datos o configuración de abstracción.
$enlace global;
$sql_error = mysql_error($enlace);
si ($ sql_error) ()
$mensaje .= "\nMensajes MySQL:\n" . mysql_error($enlace);
}
// Termina MySQL
// Podría usar una función recursiva aquí. Entiendes la idea ;-)
foreach($definido_vars como $clave => $valor)(
if(is_array ($val ) && ! in_array ($key , $ignorelist ) && count ($val ) > 0 )(
$mensaje .= "\n $matriz de claves (clave=valor):\n" ;
foreach($valor como $subclave => $subvalor)(
if(! in_array ($subclave, $ignorelist) && ! is_array ($subvalor))(
$mensaje .= $subclave . "=" . $subvalor . "\n" ;
}
elseif(! in_array ($subclave, $ignorelist) && is_array ($subvalor))(
foreach($subvalor as $subsubclave => $subsubvalor)(
if(! in_array ($subsubclave, $ignorelist))(
$mensaje .= $subsubclave . "=" . $subsubvalor . "\norte" ;
}
}
}
}
}
si no (! es_matriz ($valor) &&! in_array ($clave , $ignorelist ) && $val )(
$mensaje .= "\nVariable " . $clave. "=" . valor de $ "\n" ;
}
}
If($método == "navegador" )(
echo nl2br($mensaje);
}
elseif($método == "correo electrónico" )(
if($email == "indefinido" )(
$correo = $_SERVIDOR["SERVIDOR_ADMIN"];
}
$mresult = correo ($email, "Informe de depuración para". $_ENV [ "HOSTNAME"]. "", $mensaje);
si ($ mresultado == 1 )(
eco "Informe de depuración enviado con éxito.\n";
}
demás(
eco "Error al enviar el informe de depuración.\n";
}
}
}
?>
hace 17 años
Rutina simple para convertir un objeto get_defined_vars a XML.
función obj2xml ($v, $indent = "") (
while (lista($clave, $val) = cada uno ($v)) (
si ($clave == "__attr" ) continuar;
// Buscar __attr
if (es_objeto ($val -> __attr)) (
while (lista($clave2, $val2) = each ($val -> __attr)) (
$atributo .= " $clave2 =\" $val2 \"" ;
}
}
más $atributo = "" ;
if (es_matriz ($val) || es_objeto ($val)) (
imprimir(" $sangría<
$key$attr
>\norte");
obj2xml ($val , $sangría . " " );
imprimir(" $sangría\norte");
}
else imprimir(" $sangría<
$key$attr
>valor de $\norte");
}
}
//Objeto de ejemplo
$x -> nombre -> nombre = "Juan";
$x -> nombre -> apellido = "Smith" ;
$x -> arr [ "Fruta" ] = "Plátano" ;
$x -> arr [ "Vegeta" ] = "Zanahoria" ;
$y -> cliente = $x;
$y -> cliente -> __attr -> id = "176C4" ;
$z = get_defined_vars();
obj2xml($z["y"]);
?>
dará salida:
hace 11 años
Como nota, get_defined_vars() no devuelve un conjunto de referencias de variables (como esperaba). Por ejemplo:
// definir una variable
$mi_var = "foo" ;
// obtener nuestra lista de variables definidas
$vars_definidas = get_vars_definidas();
// ahora intente cambiar el valor a través de la matriz devuelta
$defined_vars [ "my_var" ] = "barra" ;
echo $mi_var, "\n";
?>
generará "foo" (el valor original). Sería bueno si get_defined_vars() tuviera un argumento opcional para convertirlos en referencias, pero imagino que es una solicitud bastante especializada. Puede hacerlo usted mismo (menos conveniente) con algo como:
$vars_definidos = array();
$var_names = array_keys(get_defined_vars());
foreach ($var_nombres como $var_nombre)
{
$defined_vars [ $var_name] =& $ $var_name ;
}
?>
hace 1 año
Publiqué aquí antes sobre "esto" en get_defined_vars.
Resulta que no siempre está ahí pero en ciertos casos aparecerá inexplicablemente.
Php-r"
prueba de clase(
función pública a() (var_dump(array_keys(get_defined_vars()));$a = 123;)
función pública b() (var_dump(array_keys(get_defined_vars()));$this;)
}
$t = nueva Prueba();
$t->a();
$t->b();
"
formación()
matriz("esto")
Esto no sucede en PHP 7.2 pero sucederá en PHP 5.6.
hace 1 año
Algunos comentarios aquí señalan que esta función no devolverá referencias. Sin embargo, devuelve nombres y los nombres son "referencias".
No recomendaría las sugerencias aquí que lo convierten en referencias.
función pública x($a, $b, $c) (
foreach(array_keys(get_defined_vars()) como $clave)
si ($ clave ! == "esto")
$esto->y($($clave));
}
Función pública y(&$entrada) (
$entrada++;
}
En lugar de $() también puede usar $$.
He hecho algunas cosas extravagantes en mi tiempo para hacer un código extremadamente genérico, pero nunca he tenido que hacer nada como lo anterior. Puede que ni siquiera funcione (pero debería, ya que no es diferente a $a[$key]).
También podría hacer $$key++ pero nunca he visto un código como ese que no fuera terriblemente malo (usar dinámica donde la dinámica no es beneficiosa).
Si estás haciendo algo así, dale un escrutinio adicional.
Las variables de entorno (entorno) en Windows contienen diversa información sobre la configuración del sistema y el entorno del usuario. Se hace una distinción entre las variables de entorno del usuario, del sistema y del proceso.
La forma más sencilla de ver el contenido de las variables de entorno en Windows es abrir las propiedades del sistema ( sysdm.cpl) -> Avanzado -> Variables de entorno. Como puede ver, hay dos secciones en la sección abierta: la superior contiene las variables de entorno del usuario, la inferior contiene las del sistema.
Además, las variables de entorno se almacenan en el registro del sistema. Las variables de usuario se almacenan en el archivo . sistémico - en HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment.
Puede mostrar los valores de todas las variables de entorno en la línea de comandos de Windows. El comando es simple:
El comando enumerará las variables de entorno y sus valores.
En PowerShell, para mostrar todas las variables de entorno, puede usar el comando:
Si desea mostrar el valor de una sola variable, debe usar el comando echo y el nombre de la variable debe estar entre signos de porcentaje. Por ejemplo,
eco %systemroot%
establecer > c:\tmp\env_var.txt
Las variables de entorno de un proceso en particular se pueden obtener utilizando la libre Utilidades del Explorador de procesos(de Sysinternals). Simplemente abra las propiedades del proceso y vaya a la pestaña Ambiente.
Seguro que tienes un armario o una cómoda en casa. El principio de su uso es simple: ponemos allí cosas que no necesitamos en este momento, pero que pueden ser necesarias después de un tiempo.
Las variables se organizan exactamente de la misma manera. Puede poner algo de valor en ellos y almacenarlo allí hasta que lo necesite.
Puedes poner un valor en una variable como esta:
En el código anterior, creamos la variable $name y le pusimos el valor Ivan, luego creamos la variable $age y le asignamos el valor 20.
El nombre "variable" significa que su valor puede cambiar durante la ejecución del script:
En algunos idiomas, primero se debe "declarar" una variable antes de usarla. No hay declaración en PHP: se crea una variable en el momento en que le asigna un valor.
Sin embargo, los programadores de PHP suelen decir "declarar una variable" en lugar de "crear una variable".
Además, en lugar de "poner un valor en una variable", a menudo se dice "asignar un valor".
La razón es simple: el símbolo =, gracias al cual almacenamos el valor en una variable, se llama "operador de asignación". De ahí el término "asignar".
1. El nombre de la variable comienza con el símbolo $.
2. El segundo carácter puede ser una letra o un guión bajo _
Los nombres de variables distinguen entre mayúsculas y minúsculas. $name y $Name son variables diferentes.
Puede mostrar una variable usando el comando echo que ya conocemos:
El comando echo le permite mostrar múltiples valores a la vez:
Tenga en cuenta que le pasamos 2 valores a echo, separándolos con una coma. Así podemos pasar tantos valores como queramos. Los siguientes dos ejemplos producirán el mismo resultado:
También en PHP hay una sintaxis abreviada para generar variables. En lugar de
Antes de PHP 5.4, la sintaxis abreviada solo funcionaba cuando la directiva short_open_tag estaba habilitada en la configuración de PHP, lo que también permite el uso de una etiqueta de apertura abreviada
El comando echo no siempre es conveniente para verificar el valor actual de una variable. Por ejemplo, si intenta mostrar una cadena vacía "" no se mostrará absolutamente nada en la pantalla. Y no está claro cuál es el motivo: en una variable vacía o en un código que no funciona.
Por lo tanto, la función var_dump() se usa para verificar el valor de una variable:
Resultado de la ejecución del script:
Cadena (5) "Vasya" cadena (0) ""
Como puede ver, PHP genera no solo el contenido de la variable, sino también el número de caracteres e incluso el tipo de variable (cadena). Veremos los tipos de datos en detalle en las próximas lecciones.
Puede eliminar una variable existente usando la función unset():
Y ahora es el momento de practicar un poco.
Recuerde, casi cualquier problema de PHP puede tener múltiples soluciones. Por lo tanto, si sus decisiones difieren de las escritas en este sitio, esto no significa en absoluto que haya hecho algo mal.
Escribe un guión que:
1. Crea variables denominadas título y contenido y algunos valores.
2. Muestra el valor de la variable de título dentro de la etiqueta h1 y el valor de la variable de contenido dentro de la etiqueta div.
Mostrar solución
", $título, ""; eco "
Quiero llamar su atención una vez más sobre el hecho de que esta decisión no es la única correcta. Por ejemplo, el siguiente código producirá el mismo resultado:
En esta lección, se considera el alcance. Variables PHP. Explica la diferencia entre alcance local y global, muestra cómo acceder a variables globales dentro de una función, cómo trabajar con superglobales y crear variables estáticas.
Cuando empieces aprendiendo php y comienzas a trabajar con funciones y objetos, el alcance de las variables causa cierta confusión. Afortunadamente, las reglas de PHP en este sentido son muy fáciles de entender (en comparación con otros lenguajes de programación).
El ámbito de la variable es el contexto dentro del cual se definió una variable y donde se puede acceder a ella. PHP tiene dos ámbitos variables:
El alcance variable, y especialmente el alcance local, simplifica enormemente la gestión del código. Si todas las variables fueran globales, podrían cambiarse en cualquier parte del script. Esto conduciría al caos y a los scripts grandes, ya que muy a menudo diferentes partes del script usan variables con el mismo nombre. Al limitar el alcance al contexto local, define los límites del código que puede acceder a la variable, lo que hace que el código sea más robusto, modular y más fácil de depurar.
variables con alcance global los ámbitos se denominan globales y los que tienen un ámbito local se denominan locales.
Aquí hay un ejemplo de cómo funcionan las variables globales y locales.
"; ) decirHola(); echo "Valor \$nombreGlobal: "$NombreGlobal"
"; echo "Valor \$nombrelocal: "$nombrelocal"
";
?>
¡Hola Harry! valor de $globalName: "Zoya" valor de $localName: ""
En este script, hemos creado dos variables:
Después de crear la variable y la función, el script llama a sayHello() , que imprime "¡Hola, Harry!" . Luego, el script intenta generar los valores de las dos variables utilizando la función de eco. Esto es lo que sucede:
Para acceder a una variable global fuera de la función solo escribe su nombre. Pero para acceder a una variable global dentro de una función, primero debe declarar la variable como global en la función utilizando la palabra clave global:
Function myFunction() ( global $globalVariable; // Accediendo a la variable global $globalVariable )
Si no lo hace, entonces PHP asume que está creando o usando una variable local.
Aquí hay un script de ejemplo que usa una variable global dentro de una función:
"; global $globalName; echo "¡Hola $globalName!
"; ) saluda(); ?>
Cuando se ejecuta, el script generará:
¡Hola Harry! ¡Hola Zoya!
La función sayHello() utiliza palabra clave global para declarar la variable $globalName como global. Luego puede acceder a la variable y generar su valor ("Zoya").
PHP tiene un conjunto especial de predefinidos arreglos globales que contienen información diversa. Tales arreglos se llaman superglobales, ya que se puede acceder a ellos desde cualquier parte del script, incluido el espacio de funciones interno, y no es necesario definirlos con la palabra clave global.
Aquí hay una lista de superglobales disponibles en PHP versión 5.3:
Si ejecuta el script anterior con la URL http://www.example.com/script.php?yourName=Fred, generará:
¡Hola Fred!
¡Advertencia! En un script real, esta transferencia de datos nunca debe usarse debido a la falta de seguridad. Siempre debe verificar o filtrar los datos.
El superglobal $GLOBALS es muy conveniente de usar, ya que le permite organizar el acceso a las variables globales en una función sin necesidad de usar la palabra clave global. Por ejemplo:
"; ) sayHello(); // Muestra "¡Hola, Zoya!" ?>
Cuando crea una variable local dentro de una función, solo existe mientras se ejecuta la función. Cuando la función termina, la variable local desaparece. Cuando se vuelve a llamar a la función, se crea una nueva variable local.
En la mayoría de los casos, esto funciona muy bien. Por lo tanto, las funciones son autosuficientes y siempre funcionan de la misma manera cada vez que se las llama.
Sin embargo, hay situaciones en las que sería conveniente crear una variable local que "recuerde" su valor entre llamadas a funciones. Tal variable se llama estática.
Para crear una variable estática en una función, debe usar la palabra clave static antes del nombre de la variable y asegurarse de darle un valor inicial. Por ejemplo:
Función myFunction() ( static $myVariable = 0; )
Considere una situación en la que es conveniente utilizar una variable estática. Digamos que crea una función que, cuando se llama, crea un widget e imprime la cantidad de widgets ya creados. Puedes intentar escribir un código como este usando una variable local:
"; echo createWidget() . " ya hemos creado.
"; echo createWidget() . " ya hemos creado.>
";
?>
Pero, dado que la variable $numWidgets se crea cada vez que se llama a la función, obtenemos el siguiente resultado:
Creamos algunos widgets... 1 que ya hemos creado. 1 que ya hemos creado. 1 que ya hemos creado.
Pero al usar una variable estática, podemos mantener el valor de una llamada de función a la siguiente:
"; echo createWidget() . " ya hemos creado.
"; echo createWidget() . " ya hemos creado.
"; echo createWidget() . " >ya hemos creado.
";
?>
Ahora el script producirá el resultado esperado:
Creamos algunos widgets... 1 que ya hemos creado. 2 que ya hemos creado. 3 que ya hemos creado.
Aunque una variable estática conserva su valor entre las llamadas a funciones, solo es válida mientras se ejecuta el script. Una vez que el script completa su ejecución, se destruyen todas las variables estáticas, así como las variables locales y globales.
¡Eso es todo! Consulte con frecuencia la documentación de PHP.
