I'm running into a weird issue where it seems I can't echo out an array value using heredoc syntax:
<?php
$arr = array(
array("string 1"),
array("string 2"),
array("string 3")
);
// string 3
echo $arr[2][0];
// Notice: Array to string conversion
// Var dump: string(8) "Array[0]"
echo <<<EOT
$arr[2][0]
EOT;
I feel like this is something I should know by now, but I can't find any reason why this is happening or how to solve it. Anyone willing to enlighten me?
Use {} within the heredoc:
echo <<<EOT
{$arr[2][0]}
EOT;
output:
string 3string 3
When it comes to having an array or object reference in the string needs complex parsing using the {}. Info from the link: (examples can be found there too)
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. Simply write the
expression the same way as it would appear outside the string, and
then wrap it in { and }. Since { can not be escaped, this syntax will
only be recognised when the $ immediately follows the {. Use {$ to
get a literal {$.
From the examples in the PHP manual on Strings:
// Works. When using multi-dimensional arrays, always use braces around arrays
// when inside of strings
echo "This works: {$arr['foo'][3]}";
Since heredoc syntax is equivalent to a quoted string, you need to use braces around the value:
echo <<<EOT
{$arr[2][0]}
EOT;
Output:
string 3
Demo on 3v4l.org
Related
I accidentally tested this today, can anyone explain to me why this works and what it is?
$a = array(
array(
'download' => '1500k'
)
);
echo "Test-{$a[0]['download']}";
Output : Test-1500k
double quotes evaluate the string as a expression and extract variable from it and put their value instead. but single quote show string as is.
if you want more detail you can see this answer in SO.
Your code:
echo "Test-{$a[0]['download']}";
is the same as:
echo "Test-".$a[0]['download'];
{}\ just wraps array item $a[0]['download'] in string to put its value there
In the context of a double quoted string, variables can simply be inserted by name, but this does not work for inserting array values, so the curly braces are required to let PHP know that the array value as a whole is to be inserted into the string.
In your example, if you remove the curly braces, you will see that it throws an error, and that's because PHP has no way of knowing that the [0]['download'] part is not just a string. It throws an array to string conversion error.
So that's why the curly braces are necessary.
I tried to do redirect with this syntax:
header("location: readMore.php?id=$post['post_id']");
But it didn't work. It worked only after someone suggested to put curly brackets around $post['post_id']!
The correct syntax is:
header("location: readMore.php?id={$post['post_id']}");
What does the curly brackets do in this case?
Quoting the manual:
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.
Your first code uses simple syntax, and your second code uses a complex one.
The manual does not explicitly state this, but whitespace in simple syntax seems to be an error, rendering your first code invalid. Complex syntax appears to support the same syntax as regular PHP does as far as I can see, but again this does not seem to be actually guaranteed anywhere.
String interpolation is quite flunky in general:
$a = [['derp']];
$b = $a[0];
// Works. It prints derp
echo "$b[0]";
// Doesn't work. It throws an error
echo "$b[ 0 ]";
// Works. It prints derp
echo "{$b[ 0 ]}";
// Doesn't work. It prints Array[0]
echo "$a[0][0]";
// Works. It prints derp
echo "{$a[0][0]}";
// Doesn't work. It prints { Array[0] }
echo "{ $a[0][0] }";
You get similar issues with $object -> foo and $object->foo->bar.
To me, that is pure madness. For that reason I've come to avoid double quoted strings whenever possible (the only thing I used them for are for escape sequences like "\n"). I instead use single quotes and string concatenation, like so:
header( 'location: readMore.php?id=' . $post[ 'post_id' ] );
This lets you use actual PHP syntax for variables without the horrible death trap that is string interpolation.
I came to this question to know more about constant interpolation syntax when those PHP "<<<" things are used to create multiline strings called Heredocs (which allow variable interpolation, unlike Nowdocs).
However, it seems there is no specific syntax for them, and therefore a simple workaround is to create a closure to do so. In here it is just an anonymous function assigned to a variable that will be invoked with parameters:
$int = 'intruder'; // Variable
define('con', '"smart"'); // Constant
// For complex interpolation:
// 1. Define a closure (anonymous function)
// 2. Assign it to a variable with a short name (e.g.: _ )
// 3. Invoke the function by calling the variable with parameters enclosed in ()
$_ = function ($val){return $val;};
$doc = <<<TXT
Hi there,
One day I caught this $int nearby.
I was then told that actually other {$_(con)} $int was there before.
So who came first, the chicken or the egg?
TXT; // Heredoc
echo $doc;
Output:
Hi there,
One day I caught this intruder nearby.
I was then told that actually other "smart" intruder was there before.
So who came first, the chicken or the egg?
You can test the above online on 3v4l. This was based on this answer with a few more examples with operations inside the interpolation brackets.
When you use double or single quotes, PHP will treat whatever is in it as a string unless you tell it that it’s a variable. PHP understands anything after { followed by $ as a variable and treats it as such. Here is an example:
$Text = "XYz";
echo "name-{$Text}";
The other alternative method is to use concatenation. Here is an example:
header("location: readMore.php?id=" . $post['post_id']);
Brackets allow PHP to read what's inside as a variable. You can do that this way too:
header("location: readMore.php?id=" . $post['post_id']);
PHP's simple string interpolation doesn't recognize quoted array keys, which your example demonstrates perfectly. In fact, the correct way to write this is exactly opposite depending on which syntax used: simple vs complex.
Simple syntax - Wrong
Quoted keys cannot be parsed.
header("location: readMore.php?id=$post['post_id']");
Simple syntax - Right
The unquoted string is the associative array key.
header("location: readMore.php?id=$post[post_id]");
Complex syntax - Wrong
It will work, but only if post_id is a defined constant. If not, you'll get a PHP warning.
header("location: readMore.php?id={$post[post_id]}");
Complex syntax - Right
Written just like outside the string.
header("location: readMore.php?id={$post['post_id']}");
To quote the manual on the complex syntax:
// Works, quoted keys only work using the curly brace syntax
echo "This works: {$arr['key']}";
I'd recommend using complex (curly brace) syntax if using quoted keys. And you really should be using them, because outside the string interpolation unquoted keys are actually constants. It's too bad the simple syntax won't allow them, because it makes code reviews and updating old PHP code more difficult.
I'm doing a basic quiz . I don't understand the last part:
$_SESSION["x{$user['serial']}"]
What exactly does x{5} array value mean?
x isn't defined anywhere, and in general object literals should be like {x: 5} – some help with this would be great.
session_start();
function setData($data){
if(is_array($data)){
$x = 1;
foreach ($data as $key => $value) {
$_SESSION["x$value"] = $x;
$x++;
}
}
}
$user = array('id'=>3,'serial'=>5);
setData($user);
echo $_SESSION["x{$user['serial']}"];
The curly brackets is used for expanding complex expressions inside double-quote strings, like arrays.
So, in your example, x{$user['serial']} will expand to "x5". You can also write x$value as x{$value}, both with the same result.
BTW that object literal is for Javascript, not PHP :)
You can't access (all kinds of) arrays in a double quoted string.
For instance:
echo "x$user['serial']";
This results in:
PHP Parse error: syntax error, unexpected '' (T_ENCAPSED_AND_WHITESPACE), expecting identifier (T_STRING) or variable (T_VARIABLE) or number (T_NUM_STRING) in php shell code on line 1
In other words, access array elements in an indexed array ("$user[0]") works, but accessing associative elements with a string literal doesn't.
doesn't work because it is too complicated to parse. By using accolades, you say the part should be interpreted separately.
So:
echo "x{$user['serial']}";
is equivalent to:
echo "x".$user['serial'];
The resulting code is thus:
echo $_SESSION["x".$user['serial']];
But more simple.
Given your sample $user, the result is that you access x5 from $_SESSION.
It is not x{5} because it doesn't mean anything. The expression:
"x{$user['serial']}"
is a string enclosed in double quotes. Inside strings enclosed in double quotes, PHP does what in other languages is called "variables interpolation". In plain English, it searches for variable names and replaces them with their values.
It can easily recognize variable names in strings and replace them but the things become more difficult when you want to use more complex expressions like arrays or objects. It could try to guess what the programmer wants but this is not a solution.
That's why PHP finds only simple variables inside the double quotes and relies on the programmer to signal when they want to insert complex things like arrays and objects. And the programmer uses curly braces ({ and }) to tell PHP about the complex expressions inserted in strings.
Check the documentation about string parsing on PHP manual.
Without using the curly braces, in the string "x$user['serial']" PHP recognizes the variable $user and ignores the ['serial'] part. It attempts to replace $user with its string representation and because it is an array, the final string becomes "xArray['serial']" and that is not what you want.
Using curly braces allows the programmer to write something like "x{$user[$field]}" given the variable $field was initialized forehand with the string 'serial'.
If $user['serial'] == 5 then the final outcome is $_SESSION["x5"].
Curly braces can always be used to enclose the variable names in double quoted strings. They are useful, for example, in this situation:
$sep = '--';
$str = "a{$sep}b";
// echo($str) will produce: a--b
Without curly braces around the variable $sep, the string looks like "a$sepb", PHP finds inside it the variable name $sepb and because no such variable exists, the value of $str becomes "a" and this is not what we intended.
I want PHP to echo a string stored in a variable, immediately followed by a set of square brackets containing some other text. This goes into a form that will be sent back to PHP, so PHP needs to be able to interpret the output of this command as an array item.
Here are the methods I've tried:
$var='string';
echo "string[0]" //works, but only because the variable isn't used
echo "$var[0]"; //PHP tries to treat the string as an array
echo "$var\[0]"; //the slash gets echoed
echo "$var[0\]"; //syntax error
echo "$var"."[0]"; //this is what I'm using now. It's very ugly and I want an alternative
Is there any way to make this work without breaking the string into chunks and concatenating them?
Here are the top-two ways I can think of to do this in a single output statement, the one you choose will end up being what fits your personal preference the most (and there are probably others available as well):
printf('%s[0]', $var);
echo $var . '[0]';
You can use the curly brace syntax. From the PHP manual documentation on Strings:
Any scalar variable, array element or object property with a string representation can be included via this syntax. Simply write the expression the same way as it would appear outside the string, and then wrap it in { and }. Since { can not be escaped, this syntax will only be recognised when the $ immediately follows the {.
Surround the expression within curly braces (like so: {$var}), so PHP knows where the variable begins and ends.
$var = 'foo';
echo "{$var}[0]"; // => foo[0]
This way, you wouldn't have to worry even if the variable was a quoted array index like $var['foo'] either.
Make it explicit where the variable ends with curly brace syntax:
echo "{$var}[0]";
This question already has answers here:
Closed 11 years ago.
Possible Duplicate:
curly braces in string
Just came across this piece of code and it got me curious...
$msg .= "–{$mime_boundary}–n";
The $mime_boundary var was specified earlier to be output as a string.
Did a quick test....
$var = "XmytextX";
$str ="some wrapper{$var}end of";
echo $str;
and it does indeed output into the string. I've just never seen this way of outputting a var before.
Couldn't find any documentation on it - can anyone enlighten me?
So, normally, you could use the double quotes to output any variable like so:
echo "Hello, $name";
But, what if you wanted to output an item inside an array?
echo "Hello, $row['name']";
That wouldn't work. So, you would enclose the variable in curly brackets to tell the compiler to interpolate the entire variable:
echo "Hello, {$row['name']}";
On that note, you could also use it with objects:
echo "Hello, {$row->name}";
Hope that helps!
It's called variable-interpolation. In fact you don't need the {} around the var at all. This would also work:
echo "The value of my var is $var";
However if you need a more complex variable to output it sometimes only works with the {}. For example:
echo "This is a {$very['long']['and']['complex']['variable']}";
Also note, that variable-interpolation only works in strings with double-quotes! So this wouldn't work:
echo 'this is my $var';
// outputs: this is my $var
The curly braces set a variable name off from the rest of the text, allowing you to avoid the use of spaces.
For example, if you removed the curly braces, the PHP engine would not recognize $mime_boundary as a variable in the following statement:
$msg .= "–$mime_boundary–n";
By encapsulating the variable in curly braces, you tell the PHP engine to process the variable and return its value.
It's there to eliminate ambiguity: in your case, if you wrote "some wrapper $vared of", it's clear that PHP will try to put there the value of $vared, and that's not what you want.
The curly braces let you specify which part of the string should be interpolated.
Consider $str ="some wrapper{$var}end of";
verses $str ="some wrapper$varend of";
They also allow you to insert array elements and class variables directly into strings
$str = "foobar $foo['bar']"; // parse error
$str = "foobar {$foo['bar']}";
$str = "this is my {$foo->bar[1]}";
It's related to variable interpolation.
This is explained in the manual (under "Complex (curly) syntax"). I'm curious as to why you haven't read it if you are working in PHP.
If you take a look at http://php.net/manual/en/language.types.string.php you'll see its just another way of embedding a variable within a string, it just allows you to define where the end of the variable is.
For example:
$var = "Animal"
echo "The {$var}s"; //Outputs "The Animals"