Illegal string offset error - Исправление ошибок и поиск оптимальных решений проблем

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.

Источник

Photo from Unsplash

The PHP warning: Illegal string offset happens when you try to access a string type data as if it’s an array.

In PHP, you can access a character from a string using the bracket symbol as follows:

$myString = "Hello!";

// 👇 access string character like an array
echo $myString[0]; // H
echo $myString[1]; // e
echo $myString[4]; // o

When you try to access $myString above using an index that’s not available, the PHP warning: Illegal string offset occurs.

Here’s an example:

$myString = "Hello!";

// 👇 these cause illegal offset
echo $myString["state"]; // PHP Warning:  Illegal string offset 'state' in..
echo $myString["a"]; // PHP Warning:  Illegal string offset 'a' in ..

To resolve the PHP Illegal string offset warning, you need to make sure that you are accessing an array instead of a string.

To check if you’re actually accessing an array, you can call the is_array() function before accessing the variable as follows:

$myArray = [
    "state" => true,
    "port" => 1331,
];

// 👇 check where myArray is really an array
if (is_array($myArray)) {
    echo $myArray["port"];
    echo $myArray["L"];
}

This warning will also happen when you have a multi-dimensional PHP array where one of the arrays is a string type.

Consider the following example:

$rows = [
    ["name" => "John"],
    "",
    ["name" => "Dave"]
];

foreach ($rows as $row) {
    echo $row["name"]. "n";
}

The $rows array has a string at index one as highlighted above.

When you loop over the array, PHP will produce the illegal string offset as shown below:

John
PHP Warning:  Illegal string offset 'name' in ...

Dave

To avoid the warning, you can check if the $row type is an array before accessing it inside the foreach function:

foreach ($rows as $row) {
    if(is_array($row)){
        echo $row["name"]. "n";
    }
}

When the $row is not an array, PHP will skip that row and move to the next one.

The output will be clean as shown below:

When you see this warning in your code, the first step to debug it is to use var_dump() and see the output of the variable:

From the dump result, you can inspect and see if you have an inconsistent data type like in the $rows below:

array(3) {
  [0]=>
  array(1) {
    ["name"]=>
    string(4) "John"
  }
  [1]=>
  string(0) ""
  [2]=>
  array(1) {
    ["name"]=>
    string(4) "Dave"
  }
}

For the $rows variable, the array at index [1] is a string instead of an array.

Writing an if statement and calling the is_array() function will be enough to handle it.

And that’s how you solve the PHP warning: Illegal string offset. Good luck! 👍

Источник

A string is series of characters, where a character is
the same as a byte. This means that PHP only supports a 256-character set,
and hence does not offer native Unicode support. See
details of the string
type.

Note:

On 32-bit builds, a string can be as large as up to 2GB
(2147483647 bytes maximum)

Syntax

A string literal can be specified in four different ways:

single quoted
double quoted
heredoc syntax
nowdoc syntax

Single quoted

The simplest way to specify a string is to enclose it in single
quotes (the character ').

To specify a literal single quote, escape it with a backslash
(). To specify a literal backslash, double it
(\). All other instances of backslash will be treated
as a literal backslash: this means that the other escape sequences you
might be used to, such as r or n,
will be output literally as specified rather than having any special
meaning.

Note:

Unlike the double-quoted
and heredoc syntaxes,
variables and escape sequences
for special characters will not be expanded when they
occur in single quoted strings.

<?php echo 'this is a simple string';


echo

'You can also have embedded newlines in strings this way as it is okay to do';// Outputs: Arnold once said: "I'll be back" echo 'Arnold once said: "I'll be back"';// Outputs: You deleted C:*.*? echo 'You deleted C:\*.*?';// Outputs: You deleted C:*.*? echo 'You deleted C:*.*?';// Outputs: This will not expand: n a newline echo 'This will not expand: n a newline';// Outputs: Variables do not $expand $either echo 'Variables do not $expand $either'; ?>

Double quoted

If the string is enclosed in double-quotes («), PHP will
interpret the following escape sequences for special characters:

Escaped characters

Sequence	Meaning
`n`	linefeed (LF or 0x0A (10) in ASCII)
`r`	carriage return (CR or 0x0D (13) in ASCII)
`t`	horizontal tab (HT or 0x09 (9) in ASCII)
`v`	vertical tab (VT or 0x0B (11) in ASCII)
`e`	escape (ESC or 0x1B (27) in ASCII)
`f`	form feed (FF or 0x0C (12) in ASCII)
`\`	backslash
`$`	dollar sign
`"`	double-quote
`[0-7]{1,3}`	the sequence of characters matching the regular expression is a character in octal notation, which silently overflows to fit in a byte (e.g. «400» === «00»)
`x[0-9A-Fa-f]{1,2}`	the sequence of characters matching the regular expression is a character in hexadecimal notation
`u{[0-9A-Fa-f]+}`	the sequence of characters matching the regular expression is a Unicode codepoint, which will be output to the string as that codepoint’s UTF-8 representation

As in single quoted strings, escaping any other character will
result in the backslash being printed too.

The most important feature of double-quoted strings is the fact
that variable names will be expanded. See
string parsing for
details.

Heredoc

A third way to delimit strings is the heredoc syntax:
<<<. After this operator, an identifier is
provided, then a newline. The string itself follows, and then
the same identifier again to close the quotation.

The closing identifier may be indented by space or tab, in which case
the indentation will be stripped from all lines in the doc string.
Prior to PHP 7.3.0, the closing identifier must
begin in the first column of the line.

Also, the closing identifier must follow the same naming rules as any
other label in PHP: it must contain only alphanumeric characters and
underscores, and must start with a non-digit character or underscore.

Example #1 Basic Heredoc example as of PHP 7.3.0

<?php // no indentation echo <<<END a b c n END;// 4 spaces of indentation echo <<<END a b c END;

Output of the above example in PHP 7.3:

If the closing identifier is indented further than any lines of the body, then a ParseError will be thrown:

Example #2 Closing identifier must not be indented further than any lines of the body

<?php echo <<<END a b c END;

Output of the above example in PHP 7.3:

PHP Parse error:  Invalid body indentation level (expecting an indentation level of at least 3) in example.php on line 4

If the closing identifier is indented, tabs can be used as well, however,
tabs and spaces must not be intermixed regarding
the indentation of the closing identifier and the indentation of the body
(up to the closing identifier). In any of these cases, a ParseError will be thrown.

These whitespace constraints have been included because mixing tabs and
spaces for indentation is harmful to legibility.

Example #3 Different indentation for body (spaces) closing identifier

<?php // All the following code do not work.


// different indentation for body (spaces) ending marker (tabs)

{ echo <<<END a END; }// mixing spaces and tabs in body { echo <<<END a END; }// mixing spaces and tabs in ending marker { echo <<<END a END; }

Output of the above example in PHP 7.3:

PHP Parse error:  Invalid indentation - tabs and spaces cannot be mixed in example.php line 8

The closing identifier for the body string is not required to be
followed by a semicolon or newline. For example, the following code
is allowed as of PHP 7.3.0:

Example #4 Continuing an expression after a closing identifier

<?php $values = [<<<END a b c END, 'd e f']; var_dump($values);

Output of the above example in PHP 7.3:

array(2) {
  [0] =>
  string(11) "a
  b
    c"
  [1] =>
  string(5) "d e f"
}

Warning

If the closing identifier was found at the start of a line, then
regardless of whether it was a part of another word, it may be considered
as the closing identifier and causes a ParseError.

Example #5 Closing identifier in body of the string tends to cause ParseError

<?php $values = [<<<END a b END ING END, 'd e f'];

Output of the above example in PHP 7.3:

PHP Parse error:  syntax error, unexpected identifier "ING", expecting "]" in example.php on line 6

To avoid this problem, it is safe for you to follow the simple rule:
do not choose the closing identifier that appears in the body
of the text.

Warning

Prior to PHP 7.3.0, it is very important to note that the line with the
closing identifier must contain no other characters, except a semicolon
(;).
That means especially that the identifier
may not be indented, and there may not be any spaces
or tabs before or after the semicolon. It’s also important to realize that
the first character before the closing identifier must be a newline as
defined by the local operating system. This is n on
UNIX systems, including macOS. The closing delimiter must also be
followed by a newline.

If this rule is broken and the closing identifier is not «clean», it will
not be considered a closing identifier, and PHP will continue looking for
one. If a proper closing identifier is not found before the end of the
current file, a parse error will result at the last line.

Example #6 Invalid example, prior to PHP 7.3.0

<?php class foo { public $bar = <<<EOT bar EOT; } // Identifier must not be indented ?>

Example #7 Valid example, even if prior to PHP 7.3.0

<?php class foo { public $bar = <<<EOT bar EOT; } ?>

Heredocs containing variables can not be used for initializing class properties.

Heredoc text behaves just like a double-quoted string, without
the double quotes. This means that quotes in a heredoc do not need to be
escaped, but the escape codes listed above can still be used. Variables are
expanded, but the same care must be taken when expressing complex variables
inside a heredoc as with strings.

Example #8 Heredoc string quoting example

<?php $str = <<<EOD Example of string spanning multiple lines using heredoc syntax. EOD;/* More complex example, with variables. */ class foo { var $foo; var $bar;


    function 



  


                       
  




__construct()
    {
        $this->foo = 'Foo';
        $this->bar = array('Bar1', 'Bar2', 'Bar3');
    }
}$foo = new foo();
$name = 'MyName';
echo <<<EOT

My name is "$name". I am printing some $foo->foo. Now, I am printing some {$foo->bar[1]}. This should print a capital 'A': x41 EOT; ?>

The above example will output:

My name is "MyName". I am printing some Foo.
Now, I am printing some Bar2.
This should print a capital 'A': A

It is also possible to use the Heredoc syntax to pass data to function
arguments:

Example #9 Heredoc in arguments example

<?php var_dump(array(<<<EOD foobar! EOD )); ?>

It’s possible to initialize static variables and class
properties/constants using the Heredoc syntax:

Example #10 Using Heredoc to initialize static values

<?php // Static variables function foo() { static $bar = <<<LABEL Nothing in here... LABEL; }// Class properties/constants class foo { const BAR = <<<FOOBAR Constant example FOOBAR;


    public

$baz = <<<FOOBAR Property example FOOBAR; } ?>

The opening Heredoc identifier may optionally be
enclosed in double quotes:

Example #11 Using double quotes in Heredoc

<?php echo <<<"FOOBAR" Hello World! FOOBAR; ?>

Nowdoc

Nowdocs are to single-quoted strings what heredocs are to double-quoted
strings. A nowdoc is specified similarly to a heredoc, but no
parsing is done inside a nowdoc. The construct is ideal for
embedding PHP code or other large blocks of text without the need for
escaping. It shares some features in common with the SGML
<![CDATA[ ]]> construct, in that it declares a
block of text which is not for parsing.

A nowdoc is identified with the same <<<
sequence used for heredocs, but the identifier which follows is enclosed in
single quotes, e.g. <<<'EOT'. All the rules for
heredoc identifiers also apply to nowdoc identifiers, especially those
regarding the appearance of the closing identifier.

Example #12 Nowdoc string quoting example

<?php echo <<<'EOD' Example of string spanning multiple lines using nowdoc syntax. Backslashes are always treated literally, e.g. \ and '. EOD;

The above example will output:

Example of string spanning multiple lines
using nowdoc syntax. Backslashes are always treated literally,
e.g. \ and '.

Example #13 Nowdoc string quoting example with variables

<?php class foo { public $foo; public $bar;


    function 
__construct()
    {
        $this->foo = 'Foo';
        $this->bar = array('Bar1', 'Bar2', 'Bar3');
    }
}$foo = new foo();
$name = 'MyName';
echo <<<'EOT'

My name is "$name". I am printing some $foo->foo. Now, I am printing some {$foo->bar[1]}. This should not print a capital 'A': x41 EOT; ?>

The above example will output:

My name is "$name". I am printing some $foo->foo.
Now, I am printing some {$foo->bar[1]}.
This should not print a capital 'A': x41

Example #14 Static data example

<?php class foo { public $bar = <<<'EOT' bar EOT; } ?>

Variable parsing

When a string is specified in double quotes or with heredoc,
variables are parsed within it.

There are two types of syntax: a
simple one and a
complex one.
The simple syntax is the most common and convenient. It provides a way to
embed a variable, an array value, or an object
property in a string with a minimum of effort.

The complex syntax can be recognised by the
curly braces surrounding the expression.

Simple syntax

If a dollar sign ($) is encountered, the parser will
greedily take as many tokens as possible to form a valid variable name.
Enclose the variable name in curly braces to explicitly specify the end of
the name.

<?php $juice = "apple";

"He drank some $juice juice.".PHP_EOL; // Invalid. "s" is a valid character for a variable name, but the variable is $juice. echo "He drank some juice made of $juices."; // Valid. Explicitly specify the end of the variable name by enclosing it in braces: echo "He drank some juice made of ${juice}s."; ?>

The above example will output:

He drank some apple juice.
He drank some juice made of .
He drank some juice made of apples.

Similarly, an array index or an object property
can be parsed. With array indices, the closing square bracket
(]) marks the end of the index. The same rules apply to
object properties as to simple variables.

Example #15 Simple syntax example

<?php $juices = array("apple", "orange", "koolaid1" => "purple");


echo 
"He drank some $juices[0] juice.".PHP_EOL;
echo "He drank some $juices[1] juice.".PHP_EOL;
echo "He drank some $juices[koolaid1] juice.".PHP_EOL;
class 
people {
    public $john = "John Smith";
    public $jane = "Jane Smith";
    public $robert = "Robert Paulsen";



  


                       
  




    public 
$smith = "Smith";
}$people = new people();
echo

"$people->john drank some $juices[0] juice.".PHP_EOL; echo "$people->john then said hello to $people->jane.".PHP_EOL; echo "$people->john's wife greeted $people->robert.".PHP_EOL; echo "$people->robert greeted the two $people->smiths."; // Won't work ?>

The above example will output:

He drank some apple juice.
He drank some orange juice.
He drank some purple juice.
John Smith drank some apple juice.
John Smith then said hello to Jane Smith.
John Smith's wife greeted Robert Paulsen.
Robert Paulsen greeted the two .

As of PHP 7.1.0 also negative numeric indices are
supported.

Example #16 Negative numeric indices

<?php $string = 'string'; echo "The character at index -2 is $string[-2].", PHP_EOL; $string[-3] = 'o'; echo "Changing the character at index -3 to o gives $string.", PHP_EOL; ?>

The above example will output:

The character at index -2 is n.
Changing the character at index -3 to o gives strong.

For anything more complex, you should use the complex syntax.

Complex (curly) syntax

This isn’t called complex because the syntax is complex, but because it
allows for the use of complex expressions.

Any scalar variable, array element or object property with a
string representation can be included via this syntax.
The expression is written the same way as it would appear outside the
string, and then wrapped in { and
}. Since { can not be escaped, this
syntax will only be recognised when the $ immediately
follows the {. Use {$ to get a
literal {$. Some examples to make it clear:

<?php // Show all errors error_reporting(E_ALL);$great = 'fantastic';// Won't work, outputs: This is { fantastic} echo "This is { $great}";// Works, outputs: This is fantastic echo "This is {$great}";// Works echo "This square is {$square->width}00 centimeters broad.";// Works, quoted keys only work using the curly brace syntax echo "This works: {$arr['key']}";// Works echo "This works: {$arr[4][3]}";// This is wrong for the same reason as $foo[bar] is wrong outside a string. // In other words, it will still work, but only because PHP first looks for a // constant named foo; an error of level E_NOTICE (undefined constant) will be // thrown. echo "This is wrong: {$arr[foo][3]}";// Works. When using multi-dimensional arrays, always use braces around arrays // when inside of strings echo "This works: {$arr['foo'][3]}";// Works. echo "This works: " . $arr['foo'][3];


echo 
"This works too: {$obj->values[3]->name}";
echo 
"This is the value of the var named $name: {${$name}}";
echo 
"This is the value of the var named by the return value of getName(): {${getName()}}";
echo

"This is the value of the var named by the return value of $object->getName(): {${$object->getName()}}";// Won't work, outputs: This is the return value of getName(): {getName()} echo "This is the return value of getName(): {getName()}";// Won't work, outputs: C:folder{fantastic}.txt echo "C:folder{$great}.txt" // Works, outputs: C:folderfantastic.txt echo "C:\folder\{$great}.txt" ?>

It is also possible to access class properties using variables
within strings using this syntax.

<?php class foo { var $bar = 'I am bar.'; }$foo = new foo(); $bar = 'bar'; $baz = array('foo', 'bar', 'baz', 'quux'); echo "{$foo->$bar}n"; echo "{$foo->{$baz[1]}}n"; ?>

The above example will output:

Note:

The value accessed from functions, method calls, static class variables,
and class constants inside
{$} will be interpreted as the name
of a variable in the scope in which the string is defined. Using
single curly braces ({}) will not work for
accessing the return values of functions or methods or the
values of class constants or static class variables.

<?php // Show all errors. error_reporting(E_ALL);


class

beers { const softdrink = 'rootbeer'; public static $ale = 'ipa'; }$rootbeer = 'A & W'; $ipa = 'Alexander Keith's';// This works; outputs: I'd like an A & W echo "I'd like an {${beers::softdrink}}n";// This works too; outputs: I'd like an Alexander Keith's echo "I'd like an {${beers::$ale}}n"; ?>

String access and modification by character

Characters within strings may be accessed and modified by
specifying the zero-based offset of the desired character after the
string using square array brackets, as in
$str[42]. Think of a string as an
array of characters for this purpose. The functions
substr() and substr_replace()
can be used when you want to extract or replace more than 1 character.

Note:

As of PHP 7.1.0, negative string offsets are also supported. These specify
the offset from the end of the string.
Formerly, negative offsets emitted E_NOTICE for reading
(yielding an empty string) and E_WARNING for writing
(leaving the string untouched).

Note:

Prior to PHP 8.0.0, strings could also be accessed using braces, as in
$str{42}, for the same purpose.
This curly brace syntax was deprecated as of PHP 7.4.0 and no longer supported as of PHP 8.0.0.

Warning

Writing to an out of range offset pads the string with spaces.
Non-integer types are converted to integer.
Illegal offset type emits E_WARNING.
Only the first character of an assigned string is used.
As of PHP 7.1.0, assigning an empty string throws a fatal error. Formerly,
it assigned a NULL byte.

Warning

Internally, PHP strings are byte arrays. As a result, accessing or
modifying a string using array brackets is not multi-byte safe, and
should only be done with strings that are in a single-byte encoding such
as ISO-8859-1.

Note:

As of PHP 7.1.0, applying the empty index operator on an empty string throws a fatal
error. Formerly, the empty string was silently converted to an array.

Example #17 Some string examples

<?php // Get the first character of a string $str = 'This is a test.'; $first = $str[0];// Get the third character of a string $third = $str[2];// Get the last character of a string. $str = 'This is still a test.'; $last = $str[strlen($str)-1];// Modify the last character of a string $str = 'Look at the sea'; $str[strlen($str)-1] = 'e';?>

String offsets have to either be integers or integer-like strings,
otherwise a warning will be thrown.

Example #18 Example of Illegal String Offsets

<?php $str = 'abc';var_dump($str['1']); var_dump(isset($str['1']));var_dump($str['1.0']); var_dump(isset($str['1.0']));var_dump($str['x']); var_dump(isset($str['x']));var_dump($str['1x']); var_dump(isset($str['1x'])); ?>

The above example will output:

string(1) "b"
bool(true)

Warning: Illegal string offset '1.0' in /tmp/t.php on line 7
string(1) "b"
bool(false)

Warning: Illegal string offset 'x' in /tmp/t.php on line 9
string(1) "a"
bool(false)
string(1) "b"
bool(false)

Note:

Accessing variables of other types (not including arrays or objects
implementing the appropriate interfaces) using [] or
{} silently returns null.

Note:

Characters within string literals can be accessed
using [] or {}.

Note:

Accessing characters within string literals using the
{} syntax has been deprecated in PHP 7.4.
This has been removed in PHP 8.0.

Converting to string

A value can be converted to a string using the
(string) cast or the strval() function.
String conversion is automatically done in the scope of an
expression where a string is needed. This happens when using the
echo or print functions, or when a
variable is compared to a string. The sections on
Types and
Type Juggling will make
the following clearer. See also the settype() function.

A bool true value is converted to the string
"1". bool false is converted to
"" (the empty string). This allows conversion back and
forth between bool and string values.

An int or float is converted to a
string representing the number textually (including the
exponent part for floats). Floating point numbers can be
converted using exponential notation (4.1E+6).

Note:

As of PHP 8.0.0, the decimal point character is always
a period («.«). Prior to PHP 8.0.0,
the decimal point character is defined in the script’s locale (category
LC_NUMERIC). See the setlocale() function.

Arrays are always converted to the string
"Array"; because of this, echo and
print can not by themselves show the contents of an
array. To view a single element, use a construction such as
echo $arr['foo']. See below for tips on viewing the entire
contents.

In order to convert objects to string, the magic
method __toString must be used.

Resources are always converted to strings with the
structure "Resource id #1", where 1
is the resource number assigned to the resource by PHP at
runtime. While the exact structure of this string should not be relied on
and is subject to change, it will always be unique for a given resource
within the lifetime of a script being executed (ie a Web request or CLI
process) and won’t be reused. To get a resource‘s type, use
the get_resource_type() function.

null is always converted to an empty string.

As stated above, directly converting an array,
object, or resource to a string does
not provide any useful information about the value beyond its type. See the
functions print_r() and var_dump() for
more effective means of inspecting the contents of these types.

Most PHP values can also be converted to strings for permanent
storage. This method is called serialization, and is performed by the
serialize() function.

Details of the String Type

The string in PHP is implemented as an array of bytes and an
integer indicating the length of the buffer. It has no information about how
those bytes translate to characters, leaving that task to the programmer.
There are no limitations on the values the string can be composed of; in
particular, bytes with value 0 (“NUL bytes”) are allowed
anywhere in the string (however, a few functions, said in this manual not to
be “binary safe”, may hand off the strings to libraries that ignore data
after a NUL byte.)

This nature of the string type explains why there is no separate “byte” type
in PHP – strings take this role. Functions that return no textual data – for
instance, arbitrary data read from a network socket – will still return
strings.

Given that PHP does not dictate a specific encoding for strings, one might
wonder how string literals are encoded. For instance, is the string
"á" equivalent to "xE1" (ISO-8859-1),
"xC3xA1" (UTF-8, C form),
"x61xCCx81" (UTF-8, D form) or any other possible
representation? The answer is that string will be encoded in whatever fashion
it is encoded in the script file. Thus, if the script is written in
ISO-8859-1, the string will be encoded in ISO-8859-1 and so on. However,
this does not apply if Zend Multibyte is enabled; in that case, the script
may be written in an arbitrary encoding (which is explicitly declared or is
detected) and then converted to a certain internal encoding, which is then
the encoding that will be used for the string literals.
Note that there are some constraints on the encoding of the script (or on the
internal encoding, should Zend Multibyte be enabled) – this almost always
means that this encoding should be a compatible superset of ASCII, such as
UTF-8 or ISO-8859-1. Note, however, that state-dependent encodings where
the same byte values can be used in initial and non-initial shift states
may be problematic.

Of course, in order to be useful, functions that operate on text may have to
make some assumptions about how the string is encoded. Unfortunately, there
is much variation on this matter throughout PHP’s functions:

Some functions assume that the string is encoded in some (any) single-byte
encoding, but they do not need to interpret those bytes as specific
characters. This is case of, for instance, substr(),
strpos(), strlen() or
strcmp(). Another way to think of these functions is
that operate on memory buffers, i.e., they work with bytes and byte
offsets.
Other functions are passed the encoding of the string, possibly they also
assume a default if no such information is given. This is the case of
htmlentities() and the majority of the
functions in the mbstring extension.
Others use the current locale (see setlocale()), but
operate byte-by-byte.
Finally, they may just assume the string is using a specific encoding,
usually UTF-8. This is the case of most functions in the
intl extension and in the
PCRE extension
(in the last case, only when the u modifier is used).

Ultimately, this means writing correct programs using Unicode depends on
carefully avoiding functions that will not work and that most likely will
corrupt the data and using instead the functions that do behave correctly,
generally from the intl and
mbstring extensions.
However, using functions that can handle Unicode encodings is just the
beginning. No matter the functions the language provides, it is essential to
know the Unicode specification. For instance, a program that assumes there is
only uppercase and lowercase is making a wrong assumption.

John ¶

6 years ago

I've been a PHP programmer for a decade, and I've always been using the "single-quoted literal" and "period-concatenation" method of string creation. But I wanted to answer the performance question once and for all, using sufficient numbers of iterations and a modern PHP version. For my test, I used:



php -v


PHP 7.0.12 (cli) (built: Oct 14 2016 09:56:59) ( NTS )


Copyright (c) 1997-2016 The PHP Group


Zend Engine v3.0.0, Copyright (c) 1998-2016 Zend Technologies


------ Results: -------


* 100 million iterations:


$outstr = 'literal' . $n . $data . $int . $data . $float . $n;


63608ms (34.7% slower)


$outstr = "literal$n$data$int$data$float$n";


47218ms (fastest)


$outstr =<<<EOS


literal$n$data$int$data$float$n


EOS;


47992ms (1.64% slower)


$outstr = sprintf('literal%s%s%d%s%f%s', $n, $data, $int, $data, $float, $n);


76629ms (62.3% slower)


$outstr = sprintf('literal%s%5$s%2$d%3$s%4$f%s', $n, $int, $data, $float, $data, $n);


96260ms (103.9% slower)




  


                       
  





* 10 million iterations (test adapted to see which of the two fastest methods were faster at adding a newline; either the PHP_EOL literal, or the n string expansion):


$outstr = 'literal' . $n . $data . $int . $data . $float . $n;


6228ms (reference for single-quoted without newline)


$outstr = "literal$n$data$int$data$float$n";


4653ms (reference for double-quoted without newline)


$outstr = 'literal' . $n . $data . $int . $data . $float . $n . PHP_EOL;


6630ms (35.3% slower than double-quoted with n newline)


$outstr = "literal$n$data$int$data$float$nn";


4899ms (fastest at newlines)


* 100 million iterations (a test intended to see which one of the two ${var} and {$var} double-quote styles is faster):


$outstr = 'literal' . $n . $data . $int . $data . $float . $n;


67048ms (38.2% slower)


$outstr = "literal$n$data$int$data$float$n";


49058ms (1.15% slower)


$outstr = "literal{$n}{$data}{$int}{$data}{$float}{$n}"


49221ms (1.49% slower)


$outstr = "literal${n}${data}${int}${data}${float}${n}"


48500ms (fastest; the differences are small but this held true across multiple runs of the test, and this was always the fastest variable encapsulation style)




  


                       
  





* 1 BILLION iterations (testing a completely literal string with nothing to parse in it):


$outstr = 'literal string testing';


23852ms (fastest)


$outstr = "literal string testing";


24222ms (1.55% slower)


It blows my mind. The double-quoted strings "which look so $slow since they have to parse everything for n backslashes and $dollar signs to do variable expansion", turned out to be the FASTEST string concatenation method in PHP - PERIOD!


Single-quotes are only faster if your string is completely literal (with nothing to parse in it and nothing to concatenate), but the margin is very tiny and doesn't matter.


So the "highest code performance" style rules are:


1. Always use double-quoted strings for concatenation.


2. Put your variables in "This is a {$variable} notation", because it's the fastest method which still allows complex expansions like "This {$var['foo']} is {$obj->awesome()}!". You cannot do that with the "${var}" style.


3. Feel free to use single-quoted strings for TOTALLY literal strings such as array keys/values, variable values, etc, since they are a TINY bit faster when you want literal non-parsed strings. But I had to do 1 billion iterations to find a 1.55% measurable difference. So the only real reason I'd consider using single-quoted strings for my literals is for code cleanliness, to make it super clear that the string is literal.


4. If you think another method such as sprintf() or 'this'.$var.'style' is more readable, and you don't care about maximizing performance, then feel free to use whatever concatenation method you prefer!

gtisza at gmail dot com ¶

11 years ago

The documentation does not mention, but a closing semicolon at the end of the heredoc is actually interpreted as a real semicolon, and as such, sometimes leads to syntax errors.


This works:
<?php
$foo = <<<END
abcd
END;
?>

This does not:
<?php
foo(<<<END
abcd
END;
);
// syntax error, unexpected ';'
?>

Without semicolon, it works fine:
<?php
foo(<<<END
abcd
END
);
?>

garbage at iglou dot eu ¶

6 years ago

You can use string like array of char (like C)


$a = "String array test";
var_dump($a); 
// Return string(17) "String array test"
var_dump($a[0]); 
// Return string(1) "S"
// -- With array cast --
var_dump((array) $a); 
// Return array(1) { [0]=> string(17) "String array test"}
var_dump((array) $a[0]); 
// Return string(17) "S"
- Norihiori

vseokdog at gmail dot com ¶

3 years ago

Don't forget about new E_WARNING and E_NOTICE errors from PHP 7.1.x: they have been introduced when invalid strings are coerced using operators expecting numbers (+ - * / ** % << >> | & ^) or their assignment equivalents. An E_NOTICE is emitted when the string begins with a numeric value but contains trailing non-numeric characters, and an E_WARNING is emitted when the string does not contain a numeric value.


Example:
$foo = 1 + "bob-1.3e3";  
$foo = "10.2 pigs " + 1.0; 
Will produce: Warning: A non-numeric value encountered
Read more: https://www.php.net/manual/en/migration71.other-changes.php

sideshowAnthony at googlemail dot com ¶

6 years ago

Something I experienced which no doubt will help someone . . . In my editor, this will syntax highlight HTML and the $comment:


$html = <<<"EOD"
<b>$comment</b>
EOD;
Using this shows all the same colour:
$html = <<<EOD
<b>$comment</b>
EOD;
making it a lot easier to work with

og at gams dot at ¶

15 years ago

easy transparent solution for using constants in the heredoc format: DEFINE('TEST','TEST STRING');


$const = get_defined_constants();
echo <<<END
{$const['TEST']}
END;
Result:
TEST STRING

lelon at lelon dot net ¶

18 years ago

You can use the complex syntax to put the value of both object properties AND object methods inside a string. For example... <?php class Test { public $one = 1; public function two() { return 2; } } $test = new Test(); echo "foo {$test->one} bar {$test->two()}"; ?> Will output "foo 1 bar 2".


However, you cannot do this for all values in your namespace.  Class constants and static properties/methods will not work because the complex syntax looks for the '$'.
<?php
class Test {
    const ONE = 1;
}
echo "foo {Test::ONE} bar";
?>
This will output "foo {Test::one} bar".  Constants and static properties require you to break up the string.

Ray.Paseur sometimes uses Gmail ¶

4 years ago

md5('240610708') == md5('QNKCDZO')


This comparison is true because both md5() hashes start '0e' so PHP type juggling understands these strings to be scientific notation.  By definition, zero raised to any power is zero.

steve at mrclay dot org ¶

14 years ago

Simple function to create human-readably escaped double-quoted strings for use in source code or when debugging strings with newlines/tabs/etc.


<?php
function doubleQuote($str) {
    $ret = '"';
    for ($i = 0, $l = strlen($str); $i < $l; ++$i) {
        $o = ord($str[$i]);
        if ($o < 31 || $o > 126) {
            switch ($o) {
                case 9: $ret .= 't'; break;
                case 10: $ret .= 'n'; break;
                case 11: $ret .= 'v'; break;
                case 12: $ret .= 'f'; break;
                case 13: $ret .= 'r'; break;
                default: $ret .= 'x' . str_pad(dechex($o), 2, '0', STR_PAD_LEFT);
            }
        } else {
            switch ($o) {
                case 36: $ret .= '$'; break;
                case 34: $ret .= '"'; break;
                case 92: $ret .= '\\'; break;
                default: $ret .= $str[$i];
            }
        }
    }
    return $ret . '"';
}
?>

necrodust44 at gmail dot com ¶

8 years ago

String conversion to numbers.


Unfortunately, the documentation is not correct.
«The value is given by the initial portion of the string. If the string starts with valid numeric data, this will be the value used. Otherwise, the value will be 0 (zero).»
It is not said and is not shown in examples throughout the documentation that, while converting strings to numbers, leading space characters are ignored, like with the strtod function.
<?php
    echo "     vf    r   1234" + 1;    // 1235
    var_export ("vf    r   1234" == "1234");    // true
?>

However, PHP's behaviour differs even from the strtod's. The documentation says that if the string contains a "e" or "E" character, it will be parsed as a float, and suggests to see the manual for strtod for more information. The manual says
«A hexadecimal number consists of a "0x" or "0X" followed by a nonempty sequence of hexadecimal digits possibly containing a radix character, optionally followed by a binary exponent.  A binary exponent consists of a 'P' or 'p', followed by an optional plus or minus sign, followed by a nonempty sequence of decimal digits, and indicates multiplication by a power of 2.»
But it seems that PHP does not recognise the exponent or the radix character.
<?php
    echo "0xEp4" + 1;     // 15
?>

strtod also uses the current locale to choose the radix character, but PHP ignores the locale, and the radix character is always 2E. However, PHP uses the locale while converting numbers to strings.
With strtod, the current locale is also used to choose the space characters, I don't know about PHP.

BahmanMD ¶

1 month ago

In PHP 8.2 using ${var} in strings is deprecated, use {$var} instead:


<?php
$juice = "apple";// Valid. Explicitly specify the end of the variable name by enclosing it in braces:
echo "He drank some juice made of {$juice}s.";
?>

php at richardneill dot org ¶

9 years ago

Leading zeroes in strings are (least-surprise) not treated as octal. Consider: $x = "0123" + 0; $y = 0123 + 0; echo "x is $x, y is $y"; //prints "x is 123, y is 83" in other words: * leading zeros in numeric literals in the source-code are interpreted as "octal", c.f. strtol(). * leading zeros in strings (eg user-submitted data), when cast (implicitly or explicitly) to integer are ignored, and considered as decimal, c.f. strtod().

atnak at chejz dot com ¶

18 years ago

Here is a possible gotcha related to oddness involved with accessing strings by character past the end of the string:



$string = 'a';


var_dump($string[2]);  // string(0) ""


var_dump($string[7]);  // string(0) ""


$string[7] === '';  // TRUE


It appears that anything past the end of the string gives an empty string..  However, when E_NOTICE is on, the above examples will throw the message:


Notice:  Uninitialized string offset:  N in FILE on line LINE


This message cannot be specifically masked with @$string[7], as is possible when $string itself is unset.


isset($string[7]);  // FALSE


$string[7] === NULL;  // FALSE


Even though it seems like a not-NULL value of type string, it is still considered unset.

chAlx at findme dot if dot u dot need ¶

14 years ago

To save Your mind don't read previous comments about dates ;)


When both strings can be converted to the numerics (in ("$a" > "$b") test) then resulted numerics are used, else FULL strings are compared char-by-char:
<?php
var_dump('1.22' > '01.23'); // bool(false)
var_dump('1.22.00' > '01.23.00'); // bool(true)
var_dump('1-22-00' > '01-23-00'); // bool(true)
var_dump((float)'1.22.00' > (float)'01.23.00'); // bool(false)
?>

Richard Neill ¶

15 years ago

Unlike bash, we can't do echo "a" #beep!


Of course, that would be rather meaningless for PHP/web, but it's useful for PHP-CLI. The solution is simple:  echo "x07"

headden at karelia dot ru ¶

13 years ago

Here is an easy hack to allow double-quoted strings and heredocs to contain arbitrary expressions in curly braces syntax, including constants and other function calls:


<?php// Hack declaration
function _expr($v) { return $v; }
$_expr = '_expr';// Our playground
define('qwe', 'asd');
define('zxc', 5);$a=3;
$b=4;
function 
c($a, $b) { return $a+$b; }// Usage
echo "pre {$_expr(1+2)} postn"; // outputs 'pre 3 post'
echo "pre {$_expr(qwe)} postn"; // outputs 'pre asd post'
echo "pre {$_expr(c($a, $b)+zxc*2)} postn"; // outputs 'pre 17 post'
// General syntax is {$_expr(...)}
?>

nospam at nospam dot com ¶

6 years ago

Beware that consistent with "String conversion to numbers":


<?phpif ('123abc' == 123) echo '(intstr == int) incorrectly tests as true.';// Because one side is a number, the string is incorrectly converted from intstr to int, which then matches the test number.
// True for all conditionals such as if and switch statements (probably also while loops)!
// This could be a huge security risk when testing/using/saving user input, while expecting and testing for only an integer.
// It seems the only fix is for 123 to be a string as '123' so no conversion happens.
?>

jonijnm at example dot com ¶

5 years ago

Both should work :(


<?phpclass Testing {
    public static $VAR = 'static';
    public const VAR = 'const';
        public function 
sayHelloStatic() {
        echo "hello: {$this::$VAR}";
    }
        public function 
sayHelloConst() {
        echo "hello: {$this::VAR}"; //Parse error:  syntax error, unexpected '}', expecting '['
    }
}$obj = new Testing();
$obj->sayHelloStatic();
$obj->sayHelloConst();

shd at earthling dot net ¶

13 years ago

If you want a parsed variable surrounded by curly braces, just double the curly braces:



<?php


  $foo = "bar";


  echo "{{$foo}}";


?>





will just show {bar}. The { is special only if followed by the $ sign and matches one }. In this case, that applies only to the inner braces. The outer ones are not escaped and pass through directly.

bishop ¶

16 years ago

You may use heredoc syntax to comment out large blocks of code, as follows: <?php <<<_EOC // end-of-line comment will be masked... so will regular PHP: echo ($test == 'foo' ? 'bar' : 'baz'); /* c-style comment will be masked, as will other heredocs (not using the same marker) */ echo <<<EOHTML This is text you'll never see! EOHTML; function defintion($params) { echo 'foo'; } class definition extends nothing { function definition($param) { echo 'do nothing'; } }


    how about syntax errors?; = gone, I bet.
_EOC;
?>

Useful for debugging when C-style just won't do.  Also useful if you wish to embed Perl-like Plain Old Documentation; extraction between POD markers is left as an exercise for the reader.
Note there is a performance penalty for this method, as PHP must still parse and variable substitute the string.

mark at manngo dot net ¶

6 years ago

I though that it would be helpful to add this comment so that the information at least appears on the right page on the PHP site.


Note that if you intend to use a double-quoted string with an associative key, you may run into the T_ENCAPSED_AND_WHITESPACE error. Some regard this as one of the less obvious error messages.
An expression such as:
<?php
    $fruit=array(
        'a'=>'apple',
        'b'=>'banana',
        //    etc
    );
    print 
"This is a $fruit['a']";    //    T_ENCAPSED_AND_WHITESPACE
?>

will definitely fall to pieces.
You can resolve it as follows:
<?php
    print "This is a $fruit[a]";    //    unquote the key
    print "This is a ${fruit['a']}";    //    Complex Syntax
    print "This is a {$fruit['a']}";    //    Complex Syntax variation
?>

I have a personal preference for the last variation as it is more natural and closer to what the expression would be like outside the string.
It’s not clear (to me, at least) why PHP misinterprets the single quote inside the expression but I imagine that it has something to do with the fact quotes are not part of the value string — once the string is already being parsed the quotes just get in the way … ?

Hayley Watson ¶

5 years ago

Any single expression, however complex, that starts with $ (i.e., a variable) can be {}-embedded in a double-quoted string:


<?phpecho "The expression {$h->q()["x}"]->p(9 == 0 ? 17 : 42)} gets parsed just as well as " . $h->q()["x}"]->p(9 == 0 ? 17 : 42) . " does.";?>

greenbluemoonlight at gmail dot com ¶

2 years ago

<?php \Example # 10 Simple Syntax - Solution for the last "echo" line.class people { public $john = "John Smith"; public $jane = "Jane Smith"; public $robert = "Robert Paulsen";


    public 
$smith = "Smith";
}$people = new people();
echo 
"$people->john then said hello to $people->jane.".PHP_EOL;
echo "$people->john's wife greeted $people->robert.".PHP_EOL;
echo "$people->robert greeted the two $people->smiths"; 
\Won't work 
\Outputs: Robert Paulsen greeted the two 
/**Solution:**
echo "$people->robert greeted the two $people->smithx08s"; 
\Will work
\Outputs: Robert Paulsen greeted the two Smiths
?>

Источник

586 votes

16 answers

Get the solution ↓↓↓

I get a strange PHP error after updating my php version to 5.4.0-3.

I have this array:

Array
(
    [host] => 127.0.0.1
    [port] => 11211
)

When I try to access it like this I get strange warnings

 print $memcachedConfig['host'];
 print $memcachedConfig['port'];


 Warning: Illegal string offset 'host' in ....
 Warning: Illegal string offset 'port' in ...

I really don’t want to just edit my php.ini and re-set the error level.

2021-12-4

Write your answer

344

votes

Answer

Solution:

The errorIllegal string offset 'whatever' in... generally means: you’re trying to use a string as a full array.

That is actually possible since strings are able to be treated as arrays of single characters in php. So you’re thinking the $var is an array with a key, but it’s just a string with standard numeric keys, for example:

$fruit_counts = array('apples'=>2, 'oranges'=>5, 'pears'=>0);
echo $fruit_counts['oranges']; // echoes 5
$fruit_counts = "an unexpected string assignment";
echo $fruit_counts['oranges']; // causes illegal string offset error

You can see this in action here:
http://ideone.com/fMhmkR

For those who come to this question trying to translate the vagueness of the error into something to do about it, as I was.

347

votes

Answer

Solution:

You’re trying to access astring as if it were an array, with a key that’s astring.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 anarray, but you have astring. Just a mix-up. Maybe your variable was changed, maybe it never was anarray, it’s really not important.

What can be done?

If we know we should have anarray, we should do some basic debugging to determine why we don’t have anarray. If we don’t know if we’ll have anarray orstring, 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 and or :

$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 and . For example, if the value of$array['key'] isnull,isset returnsfalse.array_key_exists will just check that, well, the key exists.

461

votes

Answer

Solution:

Please try this way…. I have tested this code…. It works….

$memcachedConfig = array("host" => "127.0.0.1","port" => "11211");
print_r($memcachedConfig['host']);

659

votes

Answer

Solution:

There are a lot of great answers here — but I found my issue was quite a bit more simple.

I was trying to run the following command:

$x['name']   = $j['name'];

and I was getting thisillegal string error on$x['name'] because I hadn’t defined the array first. So I put the following line of code in before trying to assign things to$x[]:

$x = array();

and it worked.

743

votes

Answer

Solution:

A little bit late to the question, but for others who are searching: I got this error by initializing with a wrong value (type):

$varName = '';
$varName["x"] = "test"; // causes: Illegal string offset

The right way is:

 $varName = array();
 $varName["x"] = "test"; // works

916

votes

233

votes

Answer

Solution:

Before to check the array, do this:

if(!is_array($memcachedConfig))
     $memcachedConfig = array();

830

votes

Answer

Solution:

In my case i change mysql_fetch_assoc to mysql_fetch_array and solve. It takes 3 days to solve and the other versions of my proyect run with fetch assoc.

319

votes

Answer

Solution:

In my case, I solved it when I changed in function that does sql query
after:return json_encode($array)
then:return $array

644

votes

Answer

Solution:

It works to me:

Testing Code of mine:

$var2['data'] = array ('a'=>'21','b'=>'32','c'=>'55','d'=>'66','e'=>'77');
foreach($var2 as $result)
{  
    $test = $result['c'];
}
print_r($test);

Output:55

Check it guys. Thanks

533

votes

Answer

Solution:

just use

$memcachedConfig = array();

before

 print $memcachedConfig['host'];
 print $memcachedConfig['port'];


 Warning: Illegal string offset 'host' in ....
 Warning: Illegal string offset 'port' in ....

this is because you never define what is $memcachedConfig, so by default are treated by string not arrays..

356

votes

Answer

Solution:

I solved this problem by using trim() function. the issue was with space.

so lets try

$unit_size = []; //please declare the variable type 
$unit_size = exolode("x", $unit_size);
$width  = trim ($unit_size[1] );
$height = trim ($unit_size[2] );

I hope this will help you.

933

votes

Answer

Solution:

i think the only reason for this message is because target Array is actually an array like string etc (JSON -> {«host»: «127.0.0.1»}) variable

votes

Answer

Solution:

For PHP

//Setup Array like so
$memcachedConfig = array(
  "host" => "127.0.0.1",
  "port" => "11211"
);

//Always a good practice to check if empty

if(isset($memcachedConfig['host']) && isset($memcachedConfig['port'])){

    //Some codes

    print_r ($memcachedConfig['host']);
    print_r ($memcachedConfig['port']);

}

Just make sure to check that the value returning is not empty.
So this example was for PHP so find out how to check if an array is empty in other languages.

326

votes

Answer

Solution:

Just incase it helps anyone, I was getting this error because I forgot to unserialize a serialized array. That’s definitely something I would check if it applies to your case.

947

votes

Answer

Solution:

It’s an old one but in case someone can benefit from this.
You will also get this error if your array is empty.

In my case I had:

$buyers_array = array();
$buyers_array = tep_get_buyers_info($this_buyer_id); // returns an array
...
echo $buyers_array['firstname'] . ' ' . $buyers_array['lastname'];

which I changed to:

$buyers_array = array();
$buyers_array = tep_get_buyers_info($this_buyer_id); // returns an array
...
if(is_array($buyers_array)) {
   echo $buyers_array['firstname'] . ' ' . $buyers_array['lastname']; 
} else {
   echo 'Buyers id ' . $this_buyer_id . ' not found';
}

Share solution ↓

Additional Information:

Date the issue was resolved:

2021-12-4

Link To Source

Link To Answer
People are also looking for solutions of the problem: warning: undefined array key

Didn’t find the answer?

Our community is visited by hundreds of web development professionals every day. Ask your question and get a quick answer for free.

TL; DR

Вы пытаетесь получить доступ к string, как если бы это был массив, с ключом, который string. string не поймет это. В коде мы видим проблему:

"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.

Глубина

Посмотрим на эту ошибку:

Предупреждение: Недопустимое смещение строки ‘порт’ в…

Что он говорит? В нем говорится, что мы пытаемся использовать строку 'port' как смещение для строки. Вот так:

$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 ...

Что вызывает это?

По какой-то причине вы ожидали array, но у вас есть string. Просто путаница. Возможно, ваша переменная была изменена, возможно, это никогда не было array, это действительно не важно.

Что можно сделать?

Если мы знаем, что у нас должен быть array, мы должны сделать базовую отладку, чтобы определить, почему у нас нет array. Если мы не знаем, будет ли у нас array или string, все станет немного сложнее.

Что мы можем сделать — это все виды проверки, чтобы у нас не было уведомлений, предупреждений или ошибок с такими вещами, как is_array и isset или 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
}

Есть несколько тонких различий между isset и array_key_exists. Например, если значение $array['key'] равно null, isset возвращает false. array_key_exists просто проверит, что ключ существует.

Источник

Вы пытаетесь получить доступ к string как если бы это был массив, с ключом string. string не поймет этого. В коде мы видим проблему:

"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.

В глубине

Посмотрим на эту ошибку:

Предупреждение: недопустимое смещение строки «порт» в …

Что там написано? В нем говорится, что мы пытаемся использовать строку 'port' как смещение для строки. Нравится:

$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 ...

Что вызывает это?

По какой-то причине вы ожидали array, но у вас есть string. Просто путаница. Может быть, ваша переменная была изменена, может быть, это никогда не было array, это действительно не важно.

Что может быть сделано?

Если мы знать у нас должен быть array, мы должны выполнить базовую отладку, чтобы определить, почему у нас нет array. Если мы не знаем, будет ли у нас array or string, все становится немного сложнее.

То, что мы может do — это всевозможные проверки, чтобы убедиться, что у нас нет уведомлений, предупреждений или ошибок с такими вещами, как is_array и 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
}

Есть некоторые тонкие различия между isset и array_key_exists. Например, если значение $array['key'] is null, isset Возвращает false. array_key_exists просто проверим это, ну, ключ существует.

Источник

Я действительно не хочу просто редактировать php.ini и повторно устанавливать уровень ошибки.

Пожалуйста, попробуйте этот путь …. Я проверил этот код …. Он работает ….

 $memcachedConfig = array("host" => "127.0.0.1","port" => "11211"); print_r ($memcachedConfig['host']);

Ошибка Illegal string offset 'whatever' in... обычно означает: вы пытаетесь использовать строку как полный массив.

Это действительно возможно, поскольку строки могут обрабатываться как массивы одиночных символов в php. Итак, вы думаете, что $ var – это массив с ключом, но это всего лишь строка со стандартными числовыми ключами, например:

 $fruit_counts = array('apples'=>2, 'oranges'=>5, 'pears'=>0); echo $fruit_counts['oranges']; // echoes 5 $fruit_counts = "an unexpected string assignment"; echo $fruit_counts['oranges']; // causes illegal string offset error

Вы можете увидеть это в действии здесь: http://ideone.com/fMhmkR

Для тех, кто приходит к этому вопросу, пытаясь перевести неопределенность ошибки во что-то сделать, как и я.

TL; DR

Вы пытаетесь получить доступ к string как если бы это был массив, с ключом, который является string . string не поймет это. В коде мы видим проблему:

 "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.

В глубине

Посмотрим на эту ошибку:

Предупреждение: Неверный сдвиг строки «порт» в …

Что он говорит? В нем говорится, что мы пытаемся использовать строку 'port' в качестве смещения для строки. Как это:

 $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 ...

Что вызывает это?

По какой-то причине вы ожидали array , но у вас есть string . Просто путаница. Возможно, ваша переменная была изменена, возможно, это никогда не было array , это действительно не важно.

Что может быть сделано?

Если мы знаем, что у нас должен быть array , мы должны сделать базовую отладку, чтобы определить, почему у нас нет array . Если мы не знаем, будет ли у нас array или string , все станет немного сложнее.

Мы можем сделать все, чтобы убедиться, что у нас нет уведомлений, предупреждений или ошибок с такими вещами, как is_array и isset или 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 }

Существуют некоторые тонкие различия между isset и array_key_exists . Например, если значение $array['key'] равно null , isset возвращает false . array_key_exists просто проверит это, ну, ключ существует .

Здесь есть много замечательных ответов, но я нашел, что моя проблема была довольно простой.

Я пытался запустить следующую команду:

 $x['name'] = $j['name'];

и я получал эту illegal string ошибку в $x['name'] потому что я не определил сначала массив. Поэтому я поставил следующую строку кода, прежде чем пытаться присвоить вещи $x[] :

 $x = array();

и это сработало.

Начиная с PHP 5.4 нам нужно передать одно и то же значение типа данных, которое ожидает функция. Например:

 function testimonial($id); // This function expects $id as an integer

При вызове этой функции, если строковое значение предоставляется следующим образом:

 $id = $array['id']; // $id is of string type testimonial($id); // illegal offset warning

Это вызовет предупреждение о недопустимом смещении из-за несоответствия типа данных. Чтобы решить эту проблему, вы можете использовать settype :

 $id = settype($array['id'],"integer"); // $id now contains an integer instead of a string testimonial($id); // now running smoothly

Прежде чем проверять массив, сделайте следующее:

 if(!is_array($memcachedConfig)) $memcachedConfig = array();

В моем случае я изменяю mysql_fetch_assoc на mysql_fetch_array и решаю. Требуется 3 дня, чтобы решить 🙁 и другие версии моего proyect запускаются с помощью fetch.

Просто помогите кому-нибудь, я получаю эту ошибку, потому что забыл нециализировать сериализованный массив. Это определенно то, что я проверю, применимо ли это к вашему делу.

Это старый, но в случае, если кто-то может воспользоваться этим. Вы также получите эту ошибку, если ваш массив пуст.

В моем случае у меня было:

 $buyers_array = array(); $buyers_array = tep_get_buyers_info($this_buyer_id); // returns an array ... echo $buyers_array['firstname'] . ' ' . $buyers_array['lastname'];

который я изменил на:

 $buyers_array = array(); $buyers_array = tep_get_buyers_info($this_buyer_id); // returns an array ... if(is_array($buyers_array)) { echo $buyers_array['firstname'] . ' ' . $buyers_array['lastname']; } else { echo 'Buyers id ' . $this_buyer_id . ' not found'; }

В моем случае я решил это, когда я изменил функцию, которая выполняет sql- запрос после: return json_encode($array) затем: return $array

Источник

In depth

Let’s see that error:

What causes this?

What can be done?

Syntax

Single quoted

Double quoted

Heredoc

Nowdoc

Variable parsing

Simple syntax

Complex (curly) syntax

String access and modification by character

Converting to string

Details of the String Type

Answer

Solution:

Answer

Solution:

In depth

Let’s see that error:

What causes this?

What can be done?

Answer

Solution:

Answer

Solution:

Answer

Solution:

Answer

Solution:

Answer

Solution:

Answer

Solution:

Answer

Solution:

Answer

Solution:

Answer

Solution:

Answer

Solution:

Answer

Solution:

Answer

Solution:

Answer

Solution:

Share solution ↓

Additional Information:

Didn’t find the answer?

Similar questions

Artur_hopf Активный пользователь

Artur_hopf Активный пользователь

TL; DR

Глубина

Посмотрим на эту ошибку:

Что вызывает это?

Что можно сделать?

В глубине

Посмотрим на эту ошибку:

Что вызывает это?

Что может быть сделано?

TL; DR

В глубине

Посмотрим на эту ошибку:

Что вызывает это?

Что может быть сделано?

Artur_hopf
Активный пользователь

Artur_hopf
Активный пользователь