报错："Notice: Undefined variable", "Notice: Undefined index", "Warning: Undefined array key", 还有"Notice: Undefined offset" using PHP

Question

I'm running a PHP script but I keep getting errors like this:
Notice: Undefined variable: my_variable_name in C:\wamp\www\mypath\index.php on line 10
NOTE: Undefined index: my_index at line 11 of C:\wamp\www\mypath\index.php
Warning: Undefined array key 'my_index' in C:\wamp\www\mypath\index.php at page 1

P粉116631591 · Answer

Try this

// recommended solution for recent PHP versions
$user_name = $_SESSION['user_name'] ?? '';

// pre-7 PHP versions
$user_name = '';
if (!empty($_SESSION['user_name'])) {
     $user_name = $_SESSION['user_name'];
}

Alternatively, there is a quick and easy solution:

// not the best solution, but works
// in your php setting use, it helps hiding site wide notices
error_reporting(E_ALL ^ E_NOTICE);

P粉722521204 · Answer

This error message is intended to help PHP programmers detect typos or mistakes when accessing a variable (or array element) that does not exist. Therefore, a good programmer should:

Ensure that each variable or array key has been defined before using it. If you need to use a variable inside a function, you must pass it as a parameter to the function.
Watch this error and fix it just like any other error. It might indicate a typo or a procedure not returning the data it should.
Only in rare cases beyond the programmer's control should code be added to circumvent this error. But it must not become a blind habit.

Note/Warning: Undefined variable

Although PHP does not require variable declarations, declarations are recommended to avoid some security holes or bugs where one might forget to assign a value to a variable that will be used later in the script. When a variable is not declared, PHP issues an E_WARNING level error.

This warning helps programmers detect misspelled variable names or similar errors (for example, assigning a value to a variable when a condition evaluates to false). Additionally, there may be other possible problems with uninitialized variables. As stated in the PHP manual,

This means that the variable may get a value from the included file, and this value will be used instead of the null value expected when accessing an uninitialized variable, which may lead to unpredictable results. To avoid this, it's a good idea to initialize all variables in your PHP file before using them.

There are several ways to deal with this problem:

The recommended approach is to declare each variable before using it. This way, you will only see this error if you actually make a mistake and try to use a variable that does not exist, which is why this error message appears.
```
//Initializing a variable
 $value = ""; //Initialization value; 0 for int, [] for array, etc.
 echo $value; // no error
 echo $vaule; // an error pinpoints a misspelled variable name
```

A special case is when a variable is defined but not visible in the function. In PHP, functions have their own variable scope. If you need to use an external variable in a function, its value must be passed in as a parameter of the function:
```
function test($param) {
    return $param + 1; 
}
$var = 0;
echo test($var); // now $var's value is accessible inside through $param
```

Use the null coalescing operator to suppress errors. But remember, this way PHP won't be able to notify you that you used the wrong variable name.
```
// Null coalescing operator
 echo $value ?? '';
```
For the ancient PHP versions (< 7.0) isset() with ternary can be used
```
echo isset($value) ? $value : '';
```
Please note that although this is essentially error suppression, it only works on specific errors. Therefore, it may prevent PHP from helping you by marking variables as uninitialized.
Use the @ operator to suppress errors. It's kept here for historical reasons, but seriously, this should never have happened.

Note: It is strongly recommended to only implement the first point.

Note: undefined index/undefined offset/warning: undefined array key

This tip/warning occurs when you (or PHP) try to access an undefined index of an array.

Internal array

Exactly the same attitude should be adopted when dealing with internal arrays, i.e. arrays defined in your code: initialize all keys before use. This way, the error is able to do its intended job: notify the programmer of an error in the code. Therefore, the processing method is the same:

Suggestion: Declare array elements:

//Initializing a variable
    $array['value'] = ""; //Initialization value; 0 for int, [] for array, etc.
    echo $array['value']; // no error
    echo $array['vaule']; // an error indicates a misspelled key

The special case is when a function returns an array or other value (such as null or false). Before trying to access an array element, a test must be done, for example:

$row = $stmt->fetch();
if ($row) { // the record was found and can be worked with
    echo $row['name']; 
}

External array

For external arrays (such as $_POST/$_GET/$_SESSION or JSON input), the situation is different because the programmer has no control over the contents of these arrays. Therefore, it is reasonable to check if a certain key exists or even assign a default value to a missing key.

When a PHP script contains an HTML form, naturally, there will be no form content on the first load. Therefore, such a script should check whether the form was submitted.

// for POST forms check the request method
  if ($_SERVER['REQUEST_METHOD'] === 'POST') {
      // process the form
  }
  // for GET forms / links check the important field
  if (isset($_GET['search'])) {
      // process the form
  }

Some HTML form elements, such as checkboxes, will not be sent to the server if they are not selected. In this case, it makes sense to use the null coalescing operator to assign a default value.
```
$agreed = $_POST['terms'] ?? false;
```
Optional query string elements or cookies should be handled the same way.
```
$limit = $_GET['limit'] ?? 20;
  $theme = $_COOKIE['theme'] ?? 'light';
```

But the assignment should be done at the beginning of the script. Validate all input, assign it to local variables, and use them throughout your code. This way, every variable you access will exist intentionally.