Should I Use Curly Brackets or Concatenate Variables Within Strings

console.log(`foo

bar`);

// foo

// bar

Is it wrong to use curly braces after the dollar sign inside strings

${...} is a syntax for another purpose. It is used to indirectly reference variable names. Without string interpolation, literal names in curly braces or brackets are written as string literals, thus enclosed in quotes. However, inside interpolation quotes are not used outside curly braces:

$bar = 'baz';

echo $bar , PHP_EOL;
echo ${'bar'} , PHP_EOL;

$arr = ['a' => 1, 'b' => ['x' => 'The X marks the point.']];
echo $arr['a'] , PHP_EOL;

// interpolation:
echo "$arr[a] / {$arr['a']}" , PHP_EOL;

Instead of literals you can use functions as well:

function foo(){return "bar";}

// Here we use the function return value as variable name.
// We need braces since without them the variable `$foo` would be expected
// to contain a callable

echo ${foo()} , PHP_EOL;

When interpolating, you need to enclose into curly braces only when the expression otherwise would be ambiguous:

echo "$arr[b][x]", PHP_EOL;       // "Array[x]"     
echo "{$arr['b']['x']}", PHP_EOL; // "The X marks the point."

Now we understand that ${...} is a simple interpolation "without braces" similar to "$arr[a]" since the curly braces are just for indirect varable name referencing. We can enclose this into curly braces nevertheless.

Interpolated function call forming the variable name:

echo "${foo()} / {${foo()}}", PHP_EOL;
// "baz / baz" since foo() returns 'bar' and $bar contains 'baz'.

Again, "${bar}" is equivalent to ${'bar'}, in curly braces: "{${'bar'}}".

As asked in comments,

there is another curly brace syntax to reference array keys.

$someIdentifier{'key'}

This is just an alternative syntax to PHP's common array syntax $array['key'].

In opposit to the latter, on indirect variable name references the curly braces follow immediately after the $ or the object member operator ->. To make it even more cryptic we can combine both:

$bar['baz'] = 'array item';
echo ${'ba' . 'r'}{'ba'.'z'};

which is equivalent to echo $bar['baz'];

Really weird in PHP's string interpolation: "${bar}" is valid and "${'bar'}" as well but not "$array['key']", "$array[key]" is valid instead, but both, "$array{key}" and "$array{'key'}", do not work at all.

Conclusion

It should be made a habit to use braced interpolation syntax all the time. Braced array key syntax should be avoided at all.

Always use:

"{$varname} {$array['key']} {${funcname().'_array'}['key']}"

See also PHP documentation:

• Complex curly syntax

(to distinguish from)

• Variable variables (also known as indirect variable name referencing)

• Accessing array elements

  Both square brackets and curly braces can be used interchangeably for accessing array elements (e.g. $array[42] and $array{42} will both do the same thing in the example above).

Is using curly braces in variables good practice in php

Using curly brace syntax is slightly slower. Consider the following test:

<?php

  $array = array('key'=>'val');

  $start1 = microtime(TRUE);
  for ($i = 0; $i < 100000; $i++) {
    $str = "<tag>{$array['key']}</tag>";
  }
  $end1 = microtime(TRUE);
  $result1 = $end1 - $start1;

  $start2 = microtime(TRUE);
  for ($j = 0; $j < 100000; $j++) {
    $str = "<tag>".$array['key']."</tag>";
  }
  $end2 = microtime(TRUE);
  $result2 = $end2 - $start2;

  $start3 = microtime(TRUE);
  for ($k = 0; $k < 100000; $k++) {
    $str = '<tag>'.$array['key'].'</tag>';
  }
  $end3 = microtime(TRUE);
  $result3 = $end3 - $start3;

  echo "1: $result1\n2: $result2\n3: $result3\n";

?>

On my PHP/5.2.19-win32 system, the first test (with curly braces) is slightly slower (~7%). However, the difference is so small as to be not worth worrying about, and I would say do whatever you are most comfortable with.

Slightly counter-intuitively, the second test is consistently faster than the third (~2%) - double quotes are faster than single quotes - and I would have expected it to be the other way around.

How concatenate more values inside a variable with values inside braces(Curly brackets)

You can use Object.assign to "merge" two objects. For example:

var obj1 = {a: 1, b: 2};

var obj2 = {c: 3};


var obj3 = Object.assign({}, obj1, obj2);

console.log(obj3);

a = {'1', '2', '3'};
class(a(1))
%   cell

class(a{1})
%   char

for k = 1:numel(subs)
    subject = subs{k};
    files_in(k).test = strcat('/home/data/ind/', subject, '/test_ind_', subject, '.mat');
end