You’re trying to access a string as if it were an array, with a key that’s a string. string will not understand that. In code we can see the problem:
"hello"["hello"];
// PHP Warning: Illegal string offset 'hello' in php shell code on line 1
"hello"[0];
// No errors.
array("hello" => "val")["hello"];
// No errors. This is *probably* what you wanted.
In depth
Let’s see that error:
Warning: Illegal string offset ‘port’ in …
What does it say? It says we’re trying to use the string 'port' as an offset for a string. Like this:
$a_string = "string";
// This is ok:
echo $a_string[0]; // s
echo $a_string[1]; // t
echo $a_string[2]; // r
// ...
// !! Not good:
echo $a_string['port'];
// !! Warning: Illegal string offset 'port' in ...
What causes this?
For some reason you expected an array, but you have a string. Just a mix-up. Maybe your variable was changed, maybe it never was an array, it’s really not important.
What can be done?
If we know we should have an array, we should do some basic debugging to determine why we don’t have an array. If we don’t know if we’ll have an array or string, things become a bit trickier.
What we can do is all sorts of checking to ensure we don’t have notices, warnings or errors with things like is_array and isset or array_key_exists:
$a_string = "string";
$an_array = array('port' => 'the_port');
if (is_array($a_string) && isset($a_string['port'])) {
// No problem, we'll never get here.
echo $a_string['port'];
}
if (is_array($an_array) && isset($an_array['port'])) {
// Ok!
echo $an_array['port']; // the_port
}
if (is_array($an_array) && isset($an_array['unset_key'])) {
// No problem again, we won't enter.
echo $an_array['unset_key'];
}
// Similar, but with array_key_exists
if (is_array($an_array) && array_key_exists('port', $an_array)) {
// Ok!
echo $an_array['port']; // the_port
}
There are some subtle differences between isset and array_key_exists. For example, if the value of $array['key'] is null, isset returns false. array_key_exists will just check that, well, the key exists.
Warning: illegal string offset in PHP seven is a common error that occurs when you try to use a string like a PHP array. This error can arise from typographical errors or a misunderstanding of the limitations of array operations on a string and that’s what this article will clear up for you.
As you read this article, we’ll show you code examples with code comments that explain what’s wrong with the code and why it won’t work. Now, grab your computer and launch your code editor because you’re about to learn how to fix illegal string offset in PHP.
Contents
- Why PHP Reports an Illegal String Offset in Your Code
- – You Accessed a String Like an Array
- – You Initialize a Variable as a String
- – Your Multidimensional Array Has a String Element
- – Your Variable Contains Json Encoded Data
- How To Stop Illegal String Offsets in PHP
- – Use Conditional Statements
- – Change the Variable to an Array
- – Use “is_array()” When You Loop Multidimensional Arrays
- – Decode the Json String Before You Access It
- Conclusion
Why PHP Reports an Illegal String Offset in Your Code
PHP Reports an illegal string offset in your code because of the following:
- You accessed a string like an array
- You initialize a variable as a string
- Your multidimensional array has a string element
- Your variable contains JSON encoded data
– You Accessed a String Like an Array
You can do some array-like operations on a string in PHP, but you’ll run into errors if you try to use the string like a full PHP array. In the following code, you’re telling PHP to return the element at the “string” offset. This is illegal because that offset does not exist in the string, and PHP seven will raise a warning. A similar approach will cause the illegal string offset CodeIgniter warning.
$sample_variable = “This is a string!”;
// Access it like an array? It won’t work!
echo $sample_variable[‘string’];
?>
– You Initialize a Variable as a String
Array initialization as a string will lead to a PHP seven warning when you perform other array operations on the string. That’s because it’s not allowed and it arises as a result of forgetfulness or typographical errors. In the following code, we initialized the “array” as a string, as a result, it’ll lead to the illegal string offset PHP 7 warning.
// This is a string!, or do you want an
// array?
$sample_variable = ”;
// A mistake to assign an index to the string
// leads to an error!
$sample_variable[“why?”] = “take that!”;
// The code will not reach this point!
print_r($sample_variable);
?>
The following is another example that has an array that does not exist in the function. That’s because the variable that should hold the array is a string.
function show_internal_array_elements() {
// This is a string and not an array.
$array = ”;
$array[‘first_element’] = ‘Hello’;
$array[‘second_element’] = ‘World’;
return print_r($array);
}
show_internal_array_elements();
?>
– Your Multidimensional Array Has a String Element
Multidimensional arrays that contain string as an array element will lead to the warning: illegal string offset php foreach warning. This happens because when you loop over this array, you’ll check the array keys before you proceed.
But a string in-between these arrays will not have a “key” and the following is an example.
// Sample names in a multidimensional array
$sample_names = [
[“scientist” => “Faraday”],
“”,
[“scientist” => “Rutherford”]
];
// There is a string in the “$sample_names”
// multidimensional array. So, the result
// in a PHP illegal string offset.
foreach ($sample_names as $values) {
echo $values[“scientist”]. “n”;
}
?>
– Your Variable Contains Json Encoded Data
You can’t treat JSON encoded data like an array and if you do, you’ll get a warning about an illegal offset in PHP seven. You’ll run into this error when working with Laravel and you attempt to send an object to the server. In the following code, we used an array operation on JSON encoded data, and the result is an illegal offset warning.
// An associative array
$student_scores = array(“Maguire”=>65, “Kane”=>80, “Bellingham”=>78, “Foden”=>90);
// JSON encode the array
$encode_student_scores = json_encode($student_scores, true);
// This will not work! You’ll get an illegal offset
// warning.
echo $encode_student_scores[‘Maguire’];
?>
How To Stop Illegal String Offsets in PHP
You can stop illegal string offset in your PHP code using any of the following methods:
- Use conditional statements
- Change the variable to an array
- Use “is_array()” when you loop multidimensional arrays
- Decode the JSON string before you access it
– Use Conditional Statements
Conditional statements will not get rid of the illegal offset warning in your code, but they’ll ensure PHP does not show it at all. In the following, we revisit our first example and we show how a conditional statement can show custom error messages. We use the PHP “is_array()” function to check if the variable is an array before doing anything.
$sample_variable = “This is a string!”;
// Use a combination of “is_array()” and “isset()”
// to check if “$sample_variable” is an array.
// If true, only then we print the key.
if (is_array($sample_variable) && isset($sample_variable[‘string’])) {
echo $sample_variable[‘string’];
} else {
echo “Variable is not an array or the array key does not exists.n”;
}
// Here, we use “is_array()” and “array_key_exists”
// for the check.
if (is_array($sample_variable) && array_key_exists($sample_variable[‘string’], $sample_variable)) {
echo $sample_variable[‘string’];
} else {
echo “Second response: Variable is not an array or the array key does not exist”;
}
?>
– Change the Variable to an Array
You can’t treat strings like a full PHP array, but mistakes do happen in programming. The following is the correct example of the code that initialized a string and then performed an array-like operation.
The correction is to change the string to an array using “array()” or square bracket notation. This tells PHP that the variable is an array and it will stop the illegal string offset PHP array warning.
// Fix1: Convert “$sample_variable” into an
// Array
$sample_variable = [];
// You can also use the “array()” function
// itself as shown below:
// $sample_variable = array();
// Now, this will work!
$sample_variable[“why?”] = “take that!”;
// This time, you’ll get the content of the array!
print_r($sample_variable);
?>
Also, the following is a rewrite of the function that shows the same warning. This time, we ensure the variable is an array and not a string.
function show_internal_array_elements() {
// Change it to an array and everything
// will work
$array = [];
$array[‘first_element’] = ‘Hello’;
$array[‘second_element’] = ‘World’;
return print_r($array);
}
show_internal_array_elements();
?>
– Use “is_array()” When You Loop Multidimensional Arrays
You should confirm if an element of your multidimensional array is an array using the “is_array()” function in PHP. In the following, we’ve updated the code that showed the PHP illegal offset warning earlier in the article. So, when you loop through elements of the array, you can check if it’s an array before you print its value.
// Sample names in a multidimensional array
$sample_names = [
[“scientist” => “Faraday”],
“”,
[“scientist” => “Rutherford”]
];
// Now, the “foreach()” loop has the
// is_array() function that confirms if
// the array element is an array before
// printing its value.
foreach ($sample_names as $values) {
if (is_array($values)) {
echo $values[“scientist”]. “n”;
} else {
echo “Not an array.n”;
}
}
/* Expected output:
Faraday
Not an array.
Rutherford
*/
?>
– Decode the Json String Before You Access It
If you have a JSON encoded string, decode it before treating it like an array. If you’re working with Laravel, this will prevent the illegal string offset Laravel warning. The following is not a Laravel code but you can borrow the same idea to fix the warning in Laravel. The idea is to decode JSON encoded data using “json_decode()”.
// An associative array
$student_scores = array(“Maguire”=>65, “Kane”=>80, “Bellingham”=>78, “Foden”=>90);
// JSON encode the array
$encode_student_scores = json_encode($student_scores, true);
// Fix: Decode the json before you do
// anything else. Don’t forget to include the
// second argument, ‘true’. This will allow
// it to return an array and not an Object!
$JSON_decode_student_scores = json_decode($encode_student_scores, true);
// Now, this will work as expected!.
print_r($JSON_decode_student_scores[‘Maguire’]);
?>
Conclusion
This article shows you why PHP seven shows a warning about an illegal string offset in your code. Later, we explained techniques that you can use taking note of the following:
- When you treat a string like an array, it can lead to the PHP warning about illegal offset.
- Array-like operations on JSON encoded data will cause an illegal offset warning in PHP seven.
- Use the PHP “is_array()” function to check if a variable or an element is an array before working on it.
- Use conditional statements to show a custom message in place of the illegal string offset warning in PHP seven.
- Illegal string offset meaning depends on your code, it’s either you’re treating an array like a string or you did not confirm if your variable is an array.
Everything that we discussed shows that you should not always treat strings like a PHP array. With your newly found knowledge, you know how to avoid PHP warnings about illegal offsets in your code.
- Author
- Recent Posts
Your Go-To Resource for Learn & Build: CSS,JavaScript,HTML,PHP,C++ and MYSQL. Meet The Team
Your Go-To Resource for Learn & Build: CSS,JavaScript,HTML,PHP,C++ and MYSQL. Meet The Team
