Php all variables. Variables in PHP

Php variables is a kind of information container that can contain various types of data (text, numbers, arrays, and so on). In general, variables allow you to create, store, modify, and in the future quickly access the information specified in them.

How to create a variable in PHP

Initially, the variables contain the sign $ (dollar) - designation of the use of a variable, then letters Latin alphabet(from a to z and small and large), at the end can contain numbers... Also, the name is allowed to use an underscore (not at the end).

How the variables can be named:

$ var
$ variable
$ year1945
$ _variable
How variables can not be called:

$ 1 - consists only of a digit
$ 1var - you cannot start a variable name with a digit
$ / var - only underscores are allowed of additional characters _
$ variable - Cyrillic allowed by php documentation, but not recommended
$ var iable - spaces cannot be used

Each variable is assigned a value. To assign a value, use the sign = (equals). During the processing of the script, the value of the variable can change repeatedly depending on different conditions.

$ city = "Moscow"; // the variable $ city was assigned a string (in quotes) value Moscow
$ year = 1147; // and the $ year variable was assigned the numeric value 1147
?>

$ name = "Alexander";
$ Name = "Alexey";
echo "$ name, $ Name"; // displays "Alexander, Alexey"
?>

PHP Variable Output

Separately, you should consider how to display variables using output operators, the work of which we discussed in the last lesson, Creating a PHP page. Output operators. ... Below I will give a number of illustrative examples with comments.

// This is how we assign values ​​to variables
$ name1 = "Alexey";
$ name2 = "Alexander";

// Display variables
echo $ name2; // Output: Alexander
echo "name1 is $ name1"; // name1 is Alexey

// When using single quotes, the output is
// variable name, not value
echo "name1 is $ name1"; // prints: name1 is $ name1

// you can simply display the values ​​of variables
echo $ name1; // Alexey
echo $ name1, $ name2; // Alexey Alexander
echo $ name1. "". $ name2; // Alexey Alexander
echo "$ name1, $ name2"; // Alexey, Alexander

Echo<<This uses the "here document" syntax to output
multiple lines with $ variable substitution.
END;

PHP Variable Operations

Arithmetic operations in PHP
In the case of numerical values, you can perform arithmetic operations: addition, subtraction, multiplication, and so on.

- $ a(negation) Change the sign of $ a.
$ a + $ b(addition) The sum of $ a and $ b.
$ a - $ b(subtraction) Difference between $ a and $ b.
$ a * $ b(multiplication) The product of $ a and $ b.
$ a / $ b(division) The quotient of $ a divided by $ b.
$ a% $ b(modulo division) The integer remainder of $ a divided by $ b.
Let's look at examples

$ a = 2; // note, in the case of numbers, quotes are not used
$ b = 3; // note, in the case of numbers, quotes are not used

$ result = $ a + $ b; // add variables
echo $ result; // will print 5

$ result = $ b - $ a; // add variables
echo $ result; // will output 1

Increment and decrement operations in PHP
These operations will be useful mainly when constructing loops, which we will talk about a little later.
Prefix- operators written BEFORE the variable ( - $ a; ++ $ a). Returns the value of the variable before the change.
Postfix- operators written after the variable ( $ a--; $ a--). Returns the modified value of the variable.
Increment- increasing the value.
Decrement- decreasing the value.

++ $ a Prefix increment. Increments $ a by one and returns $ a.
$ a ++ Postfix increment. Returns the value of $ a and then increments $ a by one.
- $ a Prefix decrement. Decreases $ a by one and returns the value of $ a.
$ a-- Postfix decrement. Returns the value of $ a and then decrements $ a by one.
echo "

Postfix increment

";
$ a = 5;
echo "Should be 5:". $ a ++. "\ n";

Echo "

Prefix increment

";
$ a = 5;
echo "Should be 6:". ++ $ a. "\ n";
echo "Must be 6:". $ a. "\ n";

Echo "

Postfix decrement

";
$ a = 5;
echo "Should be 5:". $ a--. "\ n";

Echo "

Prefix decrement

";
$ a = 5;
echo "Should be 4:". - $ a. "\ n";
echo "Should be 4:". $ a. "\ n";
?>

PHP assignment operations
Basic operator looks like = ... At first glance, it might seem that this operator is equal. In fact, this is not the case. In effect, the assignment operator means that the left operand is assigned the value of the right expression, (i.e., set by the resulting value). Combined operators- these are operators that allow you to use the previous values ​​of variables for subsequent operations (append to a string variable (with text) or add numeric values).

$ a = ($ b = 2) + 4; // result: $ a is set to 6, $ b is set to 2.

$ a = 2;
$ a + = 3; // sets $ a to 5, similar to writing: $ a = $ a + 3;
$ b = "Hello";
$ b. = "Peace!"; // sets $ b to "Hello World!" as does $ b = $ b. "There!";

There are also comparison operations and brain teaser, but we will talk about them in the next lessons. I will try not to frighten you with a large amount of information right away!)

This lesson explores the scope of PHP variables. Explains the difference between local and global scopes, shows how to access global variables within a function, how to work with superglobals, and how to create static variables.

When you start learning PHP and start working with functions and objects, the scope of variables is a bit confusing. Fortunately, PHP's rules in this regard are very easy to understand (compared to other programming languages).

What is scope?

Variable scope is the context within which a variable was defined and where it can be accessed. PHP has two variable scopes:

  • The global- variables can be accessed anywhere in the script
  • Local- variables can only be accessed inside the function in which they were defined

Variable scope, and especially local scope, makes it much easier to manage your code. If all the variables were global, then they could be changed anywhere in the script. This would lead to chaos and large scripts, since very often different parts of the script use variables with the same name. By scoping the local context, you define the boundaries of the code that can access the variable, making the code more robust, modular, and easier to debug.

Variables that are globally scoped are said to be global, and variables with local scope are called local.

Here's an example of how global and local variables work.

";) sayHello (); echo" Value \ $ globalName: "$ globalName"
"; echo" Value \ $ localName: "$ localName"
"; ?>

Hi Harry! $ GlobalName value: "Zoe" $ localName value: ""

In this script, we have created two variables:

  • $ globalName- this is a global variable
  • $ localName- this is local a variable that is created inside the sayHello () function.

After creating the variable and function, the script calls sayHello (), which outputs "Hello Harry!" ... The script then tries to echo the values ​​of the two variables. Here's what's going on:

  • Because $ globalName was created outside of the function, it is available anywhere in the script, so "Zoya" is displayed.
  • $ localName will only be available inside the sayHello () function. Since the echo expression is outside the function, PHP does not allow access to the local variable. Instead, PHP assumes that the code will create a new variable named $ localName, which will receive a default value of an empty string. this is why the second call to echo prints the value "" for the $ localName variable.

Accessing global variables inside a function

To access a global variable out of function just write her name. But to access the global variable inside function, you must first declare the variable as global in the function using the global keyword:

Function myFunction () (global $ globalVariable; // Access to the global variable $ globalVariable)

If you don't, PHP assumes that you are creating or using a local variable.

Here's an example script that uses a global variable inside a function:

"; global $ globalName; echo" Hello $ globalName!
";) sayHello ();?>

When executed, the script will output:

Hi Harry! Hi Zoya!

The sayHello () function uses the global keyword to declare the $ globalName variable as global. Then she can access the variable and display its value ("Zoya").

What are superglobals?

PHP has a special set of predefined global arrays that contain various information. Such arrays are called superglobals, since they are accessible from anywhere in the script, including the inner function space, and do not need to be defined using the global keyword.

Here is a list of superglobals available in PHP 5.3:

  • $ GLOBALS - list of all global variables in the script (excluding superglobals)
  • $ _GET - Contains a list of all form fields submitted by the browser using a GET request
  • $ _POST - contains a list of all form fields submitted by the browser using a POST request
  • $ _COOKIE - contains a list of all cookies sent by the browser
  • $ _REQUEST - contains all key / value combinations that are contained in the $ _GET, $ _POST, $ _COOKIE arrays
  • $ _FILES - contains a list of all files loaded by the browser
  • $ _SESSION - allows you to store and use session variables for the current browser
  • $ _SERVER - contains information about the server, such as the filename of the script being executed and the IP address of the browser.
  • $ _ENV - Contains a list of environment variables passed to PHP, for example CGI variables.
For example, you can use $ _GET to get the values ​​of the variables enclosed in the URL string of the script request, and display them on the page:

If you run the above script with the URL string http://www.example.com/script.php?yourName=Fred, it will output:

Hi Fred!

A warning! In a real script, you should never use such data transfer due to weak security. You should always check or filter your data.

The $ GLOBALS superglobal is very convenient to use because it allows you to organize access to global variables in a function without the need to use the global keyword. For example:

";) sayHello (); // Outputs" Hello, Zoe! "?>

Static variables: they are somewhere nearby

When you create a local variable inside a function, it only exists while the function is running. When the function ends, the local variable disappears. When the function is called again, a new local variable is created.

This works great in most cases. This way the functions are self-contained and always work the same every time they are called.

However, there are situations where it would be convenient to create a local variable that "remembers" its value between function calls. Such a variable is called static.

To create a static variable in a function, you must use the static keyword in front of the variable name and be sure to give it an initial value. For example:

Function myFunction () (static $ myVariable = 0;)

Let's consider a situation when it is convenient to use a static variable. Let's say you create a function that, when called, creates a widget and displays the number of widgets already created. You can try writing code like this using a local variable:


"; echo createWidget ()." we have already created.
"; echo createWidget ()." we have already created.>
"; ?>

But, since the $ numWidgets variable is created every time the function is called, we will get the following result:

We create some widgets ... 1 we have already created. 1 we have already created. 1 we have already created.

But using a static variable, we can store the value from one function call to the next:

"; echo createWidget ()." we have already created.
"; echo createWidget ()." we have already created.
"; echo createWidget ()."> we have already created.
"; ?>

The script will now produce the expected output:

We create some widgets ... 1 we have already created. 2 we have already created. 3 we have already created.

Although a static variable retains its value between function calls, it is only valid at the time the script is executed. As soon as the script finishes its execution, all static variables are destroyed, as well as local and global variables.

That's all! Check the PHP documentation frequently.

Environment variables (environment) in Windows contain various information about the system settings and the user's environment. Distinguish between user, system and process environment variables.

The easiest way to view the contents of environment variables on Windows is to open system properties ( sysdm.cpl) -> Advanced -> Environment Variables. As you can see, in the opened section there are two sections: the upper one contains the user's environment variables, the lower one contains the system ones.

In addition, environment variables are stored in the system registry. Custom variables are stored in the section. System - in HKLM \ SYSTEM \ CurrentControlSet \ Control \ Session Manager \ Environment.

You can display the values ​​of all environment variables in the Windows command line. The command is simple:

The command will list the environment variables and their values.

In PowerShell, you can use the command to display all environment variables:

If you want to display the value of only one variable, you need to use the echo command, and the name of the variable must be enclosed in percent signs. For example,

Echo% systemroot%

set> c: \ tmp \ env_var.txt

Environment variables of a specific process can be obtained using a free Process Explorer utilities(from Sysinternals). It is enough to open the properties of the process and go to the tab Environment.

13 years ago

A little gotcha to watch out for:

If you turn off RegisterGlobals and related, then use get_defined_vars (), you may see something like the following:

Array
[GLOBALS] => Array
[GLOBALS] => Array
* RECURSION *
[_POST] => Array ()
[_GET] => Array ()
[_COOKIE] => Array ()
[_FILES] => Array ()
)

[_POST] => Array ()
[_GET] => Array ()
[_COOKIE] => Array ()
[_FILES] => Array ()

)
?>

Notice that $ _SERVER isn "t there. It seems that php only loads the superglobal $ _SERVER if it is used somewhere. You could do this:

print " 

". htmlspecialchars (print_r (get_defined_vars (), true))."
" ;
print " 
". htmlspecialchars (print_r ($ _SERVER, true))."
" ;
?>

And then $ _SERVER will appear in both lists. I guess it "s not really a gotcha, because nothing bad will happen either way, but it" s an interesting curiosity nonetheless.

6 years ago

Since get_defined_vars () only gets the variables at the point you call the function, there is a simple way to get the variables defined within the current scope.

// The very top of your php script
$ vars = get_defined_vars ();

// Now do your stuff
$ foo = "foo";
$ bar = "bar";

// Get all the variables defined in current scope
$ vars = array_diff (get_defined_vars (), $ vars);

echo " 

"
;
print_r ($ vars); 
echo "
" ;
?>

15 years ago

Here is a function which generates a debug report for display or email
using get_defined_vars. Great for getting a detailed snapshot without
relying on user input.

function generateDebugReport ($ method, $ defined_vars, $ email = "undefined") (
// Function to create a debug report to display or email.
// Usage: generateDebugReport (method, get_defined_vars (), email);
// Where method is "browser" or "email".

// Create an ignore list for keys returned by "get_defined_vars".
// For example, HTTP_POST_VARS, HTTP_GET_VARS and others are
// redundant (same as _POST, _GET)
// Also include vars you want ignored for security reasons - i.e. PHPSESSID.
$ ignorelist = array ("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");

$ timestamp = date ("m / d / y h: m: s");
$ message = "Debug report created $ timestamp \ n";

// Get the last SQL error for good measure, where $ link is the resource identifier
// for mysql_connect. Comment out or modify for your database or abstraction setup.
global $ link;
$ sql_error = mysql_error ($ link);
if ($ sql_error) (
$ message. = "\ nMysql Messages: \ n". mysql_error ($ link);
}
// End MySQL

// Could use a recursive function here. You get the idea ;-)
foreach ($ defined_vars as $ key => $ val) (
if (is_array ($ val) &&! in_array ($ key, $ ignorelist) && count ($ val)> 0) (
$ message. = "\ n $ key array (key = value): \ n";
foreach ($ val as $ subkey => $ subval) (
if (! in_array ($ subkey, $ ignorelist) &&! is_array ($ subval)) (
$ message. = $ subkey. "=". $ subval. "\ n";
}
elseif (! in_array ($ subkey, $ ignorelist) && is_array ($ subval)) (
foreach ($ subval as $ subsubkey => $ subsubval) (
if (! in_array ($ subsubkey, $ ignorelist)) (
$ message. = $ subsubkey. "=". $ subsubval. "\ n" ;
}
}
}
}
}
elseif (! is_array ($ val) &&! in_array ($ key, $ ignorelist) && $ val) (
$ message. = "\ nVariable". $ key. "=". $ val. "\ n";
}
}

If ($ method == "browser") (
echo nl2br ($ message);
}
elseif ($ method == "email") (
if ($ email == "undefined") (
$ email = $ _SERVER ["SERVER_ADMIN"];
}

$ mresult = mail ($ email, "Debug Report for". $ _ENV ["HOSTNAME"]. "", $ message);
if ($ mresult == 1) (
echo "Debug Report sent successfully. \ N";
}
else (
echo "Failed to send Debug Report. \ N";
}
}
}
?>

17 years ago

Simple routine to convert a get_defined_vars object to XML.

function obj2xml ($ v, $ indent = "") (
while (list ($ key, $ val) = each ($ v)) (
if ($ key == "__attr") continue;
// Check for __attr
if (is_object ($ val -> __attr)) (
while (list ($ key2, $ val2) = each ($ val -> __attr)) (
$ attr. = "$ key2 = \" $ val2 \ "";
}
}
else $ attr = "";
if (is_array ($ val) || is_object ($ val)) (
print ("$ indent< $key$attr >\ n ");
obj2xml ($ val, $ indent. "");
print ("$ indent\ n ");
}
else print ("$ indent< $key$attr >$ val\ n ");
}
}

// Example object
$ x -> name -> first = "John";
$ x -> name -> last = "Smith";
$ x -> arr ["Fruit"] = "Bannana";
$ x -> arr ["Veg"] = "Carrot";
$ y -> customer = $ x;
$ y -> customer -> __attr -> id = "176C4";

$ z = get_defined_vars ();
obj2xml ($ z ["y"]);
?>
will output:


John
Smith


Bannana
Carrot

11 years ago

As a note, get_defined_vars () does not return a set of variable references (as I hoped). For example:

// define a variable
$ my_var = "foo";

// get our list of defined variables
$ defined_vars = get_defined_vars ();

// now try to change the value through the returned array
$ defined_vars ["my_var"] = "bar";

echo $ my_var, "\ n";

?>

will output "foo" (the original value). It "d be nice if get_defined_vars () had an optional argument to make them references, but I imagine its a rather specialized request. You can do it yourself (less conveniently) with something like:

$ defined_vars = array ();
$ var_names = array_keys (get_defined_vars ());

foreach ($ var_names as $ var_name)
{
$ defined_vars [$ var_name] = & $ $ var_name;
}

?>

1 year ago

I posted here before about "this" being in get_defined_vars.

It turns out it "s not always there but in certain cases it will inexplicably appear.

Php -r "
class Test (
public function a () (var_dump (array_keys (get_defined_vars ())); $ a = 123;)
public function b () (var_dump (array_keys (get_defined_vars ())); $ this;)
}
$ t = new Test ();
$ t-> a ();
$ t-> b ();
"

Array ()
array ("this")

This does not happen in PHP 7.2 but will happen in PHP 5.6.

1 year ago

Some comments here point out that this function wont return references. It however does return names and names are "references".

I would not recommend the suggestions here that convert it to references.

Public function x ($ a, $ b, $ c) (
foreach (array_keys (get_defined_vars ()) as $ key)
if ($ key! == "this")
$ this-> y ($ ($ key));
}

Public function y (& $ input) (
$ input ++;
}

Instead of $ () you can also use $$.

I have done some whacky things in my time to make extremely generic code but I "ve never had to do anything like the above. It might not even work (but should since it" s no different to $ a [$ key]).

You could also do $$ key ++ but I "ve never seen code like that which wasn" t horrifically bad (using dynamic where dynamic isn "t beneficial).

If you "re doing something like that then give it additional scrutiny.

SIMILAR ARTICLES