PHP: rfc:readable_var_representation

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== PHP RFC: var_representation() : readable alternative to var_export() ======
  * Version: 0.3
  * Date: 2021-01-22
  * Author: Tyson Andre, tandre@php.net
  * Status: Declined
  * First Published at: http://wiki.php.net/rfc/readable_var_representation
  * Implementation: https://github.com/php/php-src/pull/6619 (currently using another name)

===== Introduction =====

''var_export()'' is a function that gets structured information about the given variable. It is similar to var_dump() with one exception: the returned representation is (often) valid PHP code.
However, it is inconvenient to work with the representation of ''var_export()'' in many ways, especially since that function was introduced in php 4.2.0 and predates both namespaces and the short ''[]'' array syntax.
However, because the output format of ''var_export()'' is depended upon in php's own unit tests, tests of PECL modules, and the behavior or unit tests of various applications written in PHP, changing ''var_export()'' itself may be impractical.
This RFC proposes to add a new function ''var_representation(mixed $value, int $flags = 0): string'' to convert a variable to a string in a way that fixes the shortcomings of ''var_export()''

===== Proposal =====

Add a new function ''var_representation(mixed $value, int $flags = 0): string'' that always returns a string. This has the following differences from ''var_export()''

  - Unconditionally return a string instead of printing to standard output.
  - Use ''null'' instead of ''NULL'' - the former is recommended by more coding guidelines [[https://www.php-fig.org/psr/psr-2/|such as PSR-2]].
  - Escape control characters including tabs, newlines, etc., unlike var_export()/var_dump(). See the appendix [[#comparison_of_string_encoding_with_other_languages|Comparison of string encoding with other languages]] to learn more.
  - Change the way indentation is done for arrays/objects. Always add 2 spaces for every level of arrays, never 3 in objects, and put the array start on the same line as the key for arrays and objects)
  - Render lists as ''"['item1']"'' rather than ''"array(\n  0 => 'item1',\n)"''.
  - Always render empty lists on a single line instead of two lines.
  - Prepend ''\'' to class names so that generated code snippets can be used in namespaces without any issues.
  - Support the bit flag ''VAR_REPRESENTATION_SINGLE_LINE=1'' in a new optional parameter ''int $flags = 0'' accepting a bitmask. If the value of $flags includes this flags, ''var_representation()'' will return a single-line representation for arrays/objects.

<code php>
php > echo var_representation(true);
true
php > echo var_representation(1);
1
php > echo var_representation(1.00);
1.0
php > echo var_representation(null);  // differs from uppercase NULL from var_export
null
php > echo var_representation(['key' => 'value']);  // uses short arrays, unlike var_export
[
  'key' => 'value',
]
php > echo var_representation(['a','b']);  // uses short arrays, and omits array keys if array_is_list() would be true
[
  'a',
  'b',
]
php > echo var_representation(['a', 'b', 'c'], VAR_REPRESENTATION_SINGLE_LINE);  // can dump everything on one line.
['a', 'b', 'c']
php > echo var_representation([]);  // always print zero-element arrays without a newline
[]
// lines are indented by a multiple of 2, similar to var_export but not exactly the same
php > echo var_representation([(object) ['key' => (object) ['inner' => [1.0], 'other' => new ArrayObject([2])], 'other' => false]]);
[
  (object) [
    'key' => (object) [
      'inner' => [
        1.0,
      ],
      'other' => \ArrayObject::__set_state([
        2,
      ]),
    ],
    'other' => false,
  ],
]
</code>

<code php>
php > echo var_representation(fopen('test','w'));  // resources are output as null, like var_export

Warning: var_representation does not handle resources in php shell code on line 1
null
php > $x = new stdClass(); $x->x = $x; echo var_representation($x);

Warning: var_representation does not handle circular references in php shell code on line 1
(object) [
  'x' => null,
]


</code>

<code php>
// If there are any control characters (\x00-\x1f and \x7f), use double quotes instead of single quotes
// (that includes "\r", "\n", "\t", etc.)
php > echo var_representation("Content-Length: 42\r\n"); 
"Content-Length: 42\r\n"
php > echo var_representation("uses double quotes: \$\"'\\\n");
"uses double quotes: \$\"'\\\n"
php > echo var_representation("uses single quotes: \$\"'\\");
'uses single quotes: $"\'\\'


php > echo var_representation(implode('', array_map('chr', range(0, 0x1f)))), "\n"; // ascii \x00-0x1f
"\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"
php > echo var_representation(implode('', array_map('chr', range(0x20, 0x7f)))), "\n"; // ascii \x20-0x7f
" !\"#\$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f"
</code>

==== Advantages over var_export ====

=== Encoding binary data ===
This does a better job at encoding binary data in a form that is easy to edit.
var_export() does not contain any bytes except for ''\\'', ''\''', and ''\0'', 
not even control characters such as tabs, vertical tabs, backspaces, carriage returns, newlines, etc.

<code php>
php > echo var_representation("\x00\r\n\x00");
"\x00\r\n\x00"
// var_export gives no visual indication that there is a carriage return before that newline
php > var_export("\x00\r\n\x00");
'' . "\0" . '
' . "\0" . ''
// Attempting to print control characters to your terminal with var_export may cause unexpected side effects
// and unescaped control characters are unreadable
php > var_export(implode('', array_map('chr', range(0, 0x1f))));
'' . "\0" . '


hp > // (first character and closing ' was hidden by those control characters)
php > echo var_representation(implode('', array_map('chr', range(0, 0x1f))));
"\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"


// Bytes \x80 and above are passed through with no modification or encoding checks.
// PHP strings are internally just arrays of bytes and
// different php applications use different encodings.
// E.g. for this interactive shell session in a terminal expecting output with the utf-8 encoding:
php > echo var_representation('pi=π'); 
'pi=π'
php > var_export('pi=π');
'pi=π'
php > echo var_representation("\xcf\x80");
'π'
</code>

=== Cleaner output ===

This omits array keys when none of the array keys are required (i.e. when ''array_is_list()'' is true), and puts array values on the same line as array keys.
Additionally, this outputs null or unrepresentable values as ''null'' instead of ''NULL'', following [[https://www.php-fig.org/psr/psr-2/|modern coding guidelines such as PSR-2]]

=== Supporting namespaces ===

var_export() was written in php 4.2, long before php supported namespaces.
Because of that, the output of ''var_export()'' has never included backslashes to fully qualify class names,
which is inconvenient for objects that do implement ''<nowiki>__set_state</nowiki>'' (aside: ArrayObject currently doesn't)

<code php>
php > echo var_representation(new ArrayObject([1,['key' => [true]]]));
\ArrayObject::__set_state([
  1,
  [
    'key' => [
      true,
    ],
  ],
])
php > echo var_representation(new ArrayObject([1,['key'=>[true]]]),VAR_REPRESENTATION_SINGLE_LINE);
\ArrayObject::__set_state([1, ['key' => [true]]])
php > var_export(new ArrayObject([1,['key' => [true]]]));
ArrayObject::__set_state(array(
   0 => 1,
   1 => 
  array (
    'key' => 
    array (
      0 => true,
    ),
  ),
))
</code>

Without the backslash, using ''var_export'' to build a snipppet such as ''<nowiki>NS\Something::__set_state([])</nowiki>'' will have the class be incorrectly resolved to ''OtherNS\NS\Something'' if the output of var_export is used as part of a php file generated using anything other than the global namespace.

<code php>
php > namespace NS { class Something { public static function __set_state($data) {} }}
php > $code = "namespace Other; return " . var_export(new NS\Something(), true) . ";\n";
php > echo $code;
namespace OtherNS; return NS\Something::__set_state(array(
));
php > eval($code);

Warning: Uncaught Error: Class "OtherNS\NS\Something" not found in php shell code(1) : eval()'d code:1
Stack trace:
#0 php shell code(1): eval()
#1 {main}
  thrown in php shell code(1) : eval()'d code on line 1
</code>

===== When would a user use var_representation? =====

https://externals.io/message/112967#112968

<blockquote>
My hesitation remains that this is just duplicating existing
functionality with only cosmetic differences.

As a user of PHP 8.1, how would I decide whether to use print_r,
var_dump, var_export, or var_representation?

And under what circumstances would I bother to write
"var_representation($var, VAR_REPRESENTATION_SINGLE_LINE);"?
</blockquote>

An end user may wish to use these functions in the following situations:
(These are the personal opinions of the RFC's author)

==== Use var_representation when: ====

var_representation returns a parsable string representation of a variable that is easier to read than var_export.

It may be useful when any of the following apply:

  * You are generating a snippet of code to ''eval()'' in a situation where the snippet will occasionally or frequently be read by a human - see the section [[#supporting_namespaces|Supporting Namespaces]]. (If the output never needs to be read by a human, ''return unserialize(' . var_export(serialize($data), true) . ');'' can be used)
  * The output is occasionally or frequently read by humans (e.g. CLI or web app output, a REPL, unit test output, etc.). 
  * The output contains control characters such as newlines, tabs, ''\r'' or ''\x00'' and may be viewed or edited by other users in a text editor/IDE. Many IDEs may convert from windows line endings (''\r\n'') to unix line endings(''\n'') (or vice versa) automatically.
  * You want to unambiguously see control characters in the raw output regardless of how likely they are (e.g. dumping php ini settings, debugging mysterious test failures, etc)
  * You are writing unit tests for applications supporting PHP 8.1+ (or a var_representation polyfill) that test the exact string representation of the output (e.g. phpt tests of php-src and PECL extensions) - see the section [[#printing_to_stdout_by_default_or_configurably|Printing to stdout by default or configurably]].
  * You need to copy the output into a codebase that's following a modern coding style guideline such as [[https://www.php-fig.org/psr/psr-2/|modern coding guidelines such as PSR-2]] - see the section [[#cleaner_output|Cleaner Output]]. It saves time if you don't have to remove array keys of lists and convert ''array()'' to ''[]''.

==== Use VAR_REPRESENTATION_SINGLE_LINE when: ====

This flag may be useful when any of the following apply:

  * You are writing or modifying tests of exact variable representation and want to write the equivalent of
    <code php>
    $this->assertSame("[\\NS\\MyClass::__set_state(['prop' => true]), 2]", $repr)
    // instead of the much longer and harder to type
    $this->assertSame("[\n  \\NS\\MyClass::__set_state([\n    prop' => true,\n  ],\n  2,\n]", $repr)
    </code>
  * You are generating human-readable output and expect the output to be a small object/array - see the section [[#printing_to_stdout_by_default_or_configurably|Printing to stdout by default or configurably]]
  * You want the output to be as short as possible while still being somewhat human readable, e.g. sending an extremely long array representation over the network, or are saving it to a file/cache/external service, or you're using var_representation($mixed) as an array key for thousands of objects.

==== Use var_export when: ====

var_representation returns a parsable string representation of a variable (that has the limitations described in this RFC)

  * You are writing an application or library that would benefit from behaving the exact same way in php 8.0 and 8.1, and polyfilling is impractical (e.g. for performance reasons or packaging requirements such as being distributed without additional dependencies (e.g. a single-file script))
  * You prefer string output escaped with single quotes mixed with newlines, tabs, and embedded control characters (especially if control characters are unlikely), or want to render NULL as an uppercase scalar.
  * You need to generate output that can be ''eval()''ed even in PHP versions [[https://wiki.php.net/rfc/shortsyntaxforarrays|5.3 or older]].

==== Use var_dump when: ====

  * You do not need valid php code.
  * You need to inspect a datastructure to determine if it contains references or recursive data structures such as recursive objects or recursive array references.
  * You need a human-readable representation of data, don't need valid php syntax, and want to distinguish between 

==== Use debug_zval_dump when: ====

[[https://www.php.net/manual/en/function.debug-zval-dump.php|debug_zval_dump]] dumps a string representation of an internal zend value to output.

  * You do not need valid php code.
  * You are looking into bugs in the internals of php (e.g. incorrect reference counting of php values leading to memory leaks or premature freeing) and need to know exact reference counts
  * You are generating a test case for a PECL extension or php-src validating that a reference counting bug is fixed.

<code php>
php > $y = [new stdClass()]; $y[1] = &$y[0]; 
php > debug_zval_dump($y);
array(2) refcount(2){
  [0]=>
  &object(stdClass)#1 (0) refcount(1){
  }
  [1]=>
  &object(stdClass)#1 (0) refcount(1){
  }
}
php > var_dump($y);
array(2) {
  [0]=>
  &object(stdClass)#1 (0) {
  }
  [1]=>
  &object(stdClass)#1 (0) {
  }
}
php > var_export($y);  // here, you get valid php code but don't see the object ids and can't tell if they're different objects
array (
  0 => 
  (object) array(
  ),
  1 => 
  (object) array(
  ),
)
</code>

==== Use print_r when: ====

[[https://www.php.net/print_r|print_r]] prints human-readable information about a variable - it is like print() but recursive.

  * You do not need valid php code.
  * You want human-readable output, string escaping isn't a concern for your use case, and differentiating between strings, integers, floats, booleans, and null doesn't need to happen (printed the same way as print()). This can be useful if keys and values are almost always the same types.

The below snippet is an example of where you may not want to use print_r().

<code php>
php > print_r([['key' => 'first', 'other' => 'second', 'third' => '1'], '1', 1, 1.0, true, false, null, '']);
Array
(
    [0] => Array
        (
            [key] => first
            [other] => second
            [third] => 1
        )

    [1] => 1
    [2] => 1
    [3] => 1
    [4] => 1
    [5] => 
    [6] => 
    [7] => 
)
</code>

===== Backward Incompatible Changes =====

None, except for newly added function and constant names. The output format of ''var_export()'' is not changed in any way.

===== Proposed PHP Version(s) =====
8.1

===== RFC Impact =====
==== To SAPIs ====
None

==== To Existing Extensions ====
No

==== To Opcache ====
No impact

==== New Constants ====

''VAR_REPRESENTATION_SINGLE_LINE''

===== Unaffected PHP Functionality =====

''var_export()'' does not change in any way.

===== Future Scope =====

==== Extending $flags ====

Future RFCs may extend ''$flags'' by adding more flags, or by allowing an array to be passed to ''$flags''.

Adding more flags here would increase the scope of the rfc and complexity of implementing the change and for reviewing/understanding the implementation.

=== Supporting an indent option ===

This was left out since I felt it would increase the scope of the RFC too much.

If  an ''indent'' option might be supported by also allowing ''var_representation(value: $value, flags: ['flags' => VAR_REPRESENTATION_SINGLE_LINE, 'indent' => "\t"])'' or by bitmask flags such as ''VAR_REPRESENTATION_INDENT_FOUR_SPACES''/''VAR_REPRESENTATION_INDENT_TABS''/''VAR_REPRESENTATION_INDENT_NONE''.

The fact that embedded newlines are now no longer emitted as parts of strings makes it easier to efficiently convert the indentation to spaces or tabs using ''preg_replace'' or ''preg_replace_callback''

<code php>
php > echo var_representation([[['key' => 'value  with  space']]]);
[
  [
    [
      'key' => 'value  with  space',
    ],
  ],
]
php > echo preg_replace('/^((  )+)/m', '\1\1', var_representation([[['key' => 'value  with  space']]]));
[
    [
        [
            'key' => 'value  with  space',
        ],
    ],
]
</code>
````

==== Adding magic methods such as __toRepresentation() to PHP ====

This is outside of the scope of this RFC, but it is possible future RFCs by others may amend the representation of ''var_representation()''
before php 8.1 is released or through adding new options to $flags.

Others have suggested adding magic methods that would convert objects to a better representation.
No concrete proposals have been made yet. Multiline formatting and the detection of recursive data structures is a potential concern.

Another possibility is to add a magic method such as ''<nowiki>__toConstructorArgs</nowiki>(): array'' 
which would allow converting `$point` to the string '''new Point(x: 1, y: 2)''' or '''new Point(1, 2)'''
if that magic method is defined.

==== Customizing string representations ====

It may be useful to override this string representation through additional flags, callbacks, or other mechanisms.
However, I don't know if there's widespread interest in that, and this would increase the scope of this RFC.

==== Emitting code comments in result about references/types/recursion ====

Adding a comment such as ''/* resource(2) of type (stream) */ null'' to the var_representation output with an opt-in flag (e.g. ''VAR_REPRESENTATION_ADD_TYPE_COMMENTS'') to add this information may be useful to explore in follow-up work (to meet more use cases of ''var_dump'').

(Or ''/* RECURSION  */ NULL'', or ''[/* reference */ 123, /* reference */ 123]'', etc.)

===== Discussion =====

==== PHP already has a lot of ways to dump variables ====

https://externals.io/message/112924#112943

<blockquote>
While I agree that all the suggestions in this thread would improve
var_export, I worry that it is failing a "smell test" that I often apply:

"If you're struggling to come up with the appropriate name for something
that you're creating, maybe you're creating the wrong thing."

In this case, the reason it's difficult to name is that PHP already has
rather a lot of different ways to produce a human-readable string from a
variable. The synopses in the manual aren't particularly enlightening:

print_r — Prints human-readable information about a variable
var_dump — Dumps information about a variable
var_export — Outputs or returns a parsable string representation of a
variable
Then there's the slightly more exotic (and rather less useful than it
once was) debug_zval_dump; serialization formats that are reasonably
human-friendly like json_encode; and any number of frameworks and
userland libraries that define their own "dumper" functions because they
weren't satisfied with any of the above.

The name of any new function in this crowded space needs to somehow tell
the user why they'd use this one over the others - and, indeed, when
they wouldn't use it over the others.

Should we be aiming for a single function that can take over from some
or all of the others, and deprecate them, rather than just adding to the
confusion?
</blockquote>

https://externals.io/message/112924#112953

<blockquote>
<blockquote>
IMO print_r/var_dump should be kept out of this discussion. Those are human
readable outputs for human consumption. var_export() is about a machine
readable output for recreating initial state within a runtime. The
requirements presented are wholly different.

-Sara
</blockquote>

If the goal of var_export is only to have some machine-readable output, the following will do it:

<code php>
<?php
function my_var_export(mixed $x): string {
$serialized = \base64_encode(\serialize($x));
return "\unserialize(\base64_decode('$serialized'))";
}
?>
</code>

In reality, the output of var_export() is both machine-readable and human-readable.

—Claude
</blockquote>

I believe that the improvements of var_representation make adding a new function worth it. See the section [[#use_var_representation_when|"Use var_representation when"]].

As mentioned earlier, a lot of existing php code depends on the exact default output of var_export() (e.g. unit tests of php-src itself and otherwise), which was introduced in php 4.2 and predates namespaces and short arrays.
Changing it would result in a lot of work in php-src, PECL, and projects written in PHP to support both old and new syntaxes for var_export.

The last time ''var_export()'' changed was from ''<nowiki>stdClass::__set_state(array())</nowiki>'' to ''(object) []'' in PHP 7.3.0, but that was something that had a clearer reason to fix - ''<nowiki>stdClass::__set_state</nowiki>'' is an undeclared function and many users were inconvenienced by being unable to generate code for stdClass instances.

===== Vote =====
This is a Yes/No vote, requiring 2/3 majority. Voting started on 2021-02-05 and ended 2021-02-19.

<doodle title="Add var_representation($value, int $flags=0): string to php?" auth="tandre" voteType="single" closed="true">
   * Yes
   * No
</doodle>

===== References =====

  * https://externals.io/message/112967 "[RFC] var_representation() : readable alternative to var_export()"
  * https://externals.io/message/112924 "Proposal: short_var_export($value, bool $return=false, int $flags=0)"
  * https://externals.io/message/109415 "[RFC][DISCUSSION] Change var_export() array syntax to use short hand arrays" (A competing RFC that started discussion 9 months ago in March 2020). See quote in the section [[#printing_to_stdout_by_default_or_configurably|Printing to stdout by default or configurably]] about previous discussions not being particularly open to changing var_export behavior.
  * https://wiki.php.net/rfc/var-export-array-syntax "PHP RFC: Change var_export() array syntax to use shorthand arrays" (A competing RFC that started discussion 9 months ago in March 2020)

===== Appendix =====
==== Comparison of string encoding with other languages ====

See https://man7.org/linux/man-pages/man7/ascii.7.html for details about ascii
<blockquote>
ASCII is the American Standard Code for Information Interchange.
It is a 7-bit code (with 128 characters).  Many 8-bit codes (e.g., ISO 8859-1) contain
ASCII as their lower half.  The international counterpart of
ASCII is known as ISO 646-IRV.
</blockquote>

If there are any control characters (in the ranges \x00-\x1f and \x7f), ''var_representation()'' uses double quotes instead of single quotes.
If there are no control characters, strings are represented the way ''var_export()'' currently represents them.

<code php>
php > echo var_representation(implode('', array_map('chr', range(0, 0x1f)))), "\n"; // ascii \x00-0x1f
"\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"
php > echo var_representation(implode('', array_map('chr', range(0x20, 0x7f)))), "\n"; // ascii \x20-0x7f
" !\"#\$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f"
</code>

Python appears to have the same inner representation with shorter representations only for ''\t\n\r'' (Python allows escaping inside of single quoted strings).

<code python>
# \x00-\x1f
print(repr(''.join(chr(c) for c in range(0, 0x20))))                          
'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f'
# \x20-\x7f
print(repr(''.join(chr(c) for c in range(0x20, 0x80))))                       
' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f'
</code>


JSON escapes a wider range of control characters, but the format does not require escaping backspaces(\x7f), which are permitted in string literals.

<code javascript>
> console.log(JSON.stringify("\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f"));
"\u0000\u0001\u0002\u0003\u0004\u0005\u0006\u0007\b\t\n\u000b\f\r\u000e\u000f\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001a\u001b\u001c\u001d\u001e\u001f"
> console.log(JSON.stringify(" !\"#$%&'()*+,-.\/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f"));
" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"
</code>

Ruby has additional shorter escapes for ''\a\b\v\f'' and also escapes backslashes. For many users, ''\a\b\v\f'' are obscure terminal/text file functionality and the hex representation may be more useful.

<code ruby>
puts("\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f".inspect)
"\u0000\u0001\u0002\u0003\u0004\u0005\u0006\a\b\t\n\v\f\r\u000E\u000F\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001A\e\u001C\u001D\u001E\u001F"
puts(" !\"#$%&'()*+,-.\/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f".inspect)
" !\"\#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u007F"
</code>

===== Rejected Features =====

==== Printing to stdout by default or configurably ====

Printing to stdout and creating a string representation are two distinct behaviors, which some would argue should not be combined into the same function.
It is simple enough to explicitly write ''echo var_representation($value);''

The name ''var_representation()'' was chosen to make it clearer that the function returning a representation, rather than performing an action such as ''dump''ing or ''export''ing the value.

https://externals.io/message/112924#112925
<blockquote>
The formatting of var_export is certainly a recurring complaint, and
previous discussions were not particularly open to changing current
var_export behavior, so adding a new function seems to be the way to
address the issue (the alternative would be to add a flag to var_export).

I like the idea of the "one line" flag. Actually, this is the main part I'm
interested in :) With the one line flag, this produces the ideal formatting
for PHPT tests that want to print something like "$v1 + $v2 = $v3". None of
our current dumping functions are suitable for this purpose (json_encode
comes closest, but has edge cases like lack of NAN support.)

Some notes:

  * You should drop the $return parameter and make it always return. As this is primarily an export and not a dumping function, printing to stdout doesn't make sense to me.  * For strings, have you considered printing them as double-quoted and escaping more characters? This would avoid newlines in oneline mode. And would allow you to escape more control characters. I also find the current ''<nowiki>'' . "\0" . ''</nowiki>'' format for encoding null bytes quite awkward.
  * I don't like the short_var_export() name. Is "short" really the primary characteristic of this function? Both var_export_pretty and var_export_canonical seem better to me, though I can't say they're great either. I will refrain from proposing real_var_export() ... oops :P

Regards,

Nikita
</blockquote>

==== Calling this var_export_something ====

The var_export() function will print to stdout by default, unless ''$return = true'' is passed in.
I would find it extremely inconsistent and confusing to add a new global function ''var_export_something()'' that does not print to stdout by default.

==== Using an object-oriented api ====

This was rejected because the most common use cases would not need the ability to customize the output.
Additionally, it is possible to use $flags (possibly also allowing an array containing callbacks) to achieve a similar result to method overrides.

https://externals.io/message/112924#112944
<blockquote>
Alternatively how about making a VarExporter class.

<code php>
$exporter = new VarExporter; // Defaults to basic set of encoding options TBD
$exporter->setIndent('  '); // 2 spaces, 1 tab, whatever blows your dress up
$exporter->setUserShortArray(false); // e.g. use array(...)
etc...

$serialized = $exporter->serialize($var); // Exports to a var
$exporter->serializeToFile($var, '/tmp/include.inc'); // Exports to a file
$exporter->serializeToStream($var, $stream); // Exports to an already open stream
</code>

And if you want the defaults, then just:

<code php>
$serialized = (var VarExporter)->serialize($var);
</code>

Potentially, one could also allow overriding helper methods to perform transformations along the way:

<code php>
// VarExporter which encodes all strings as base64 blobs.
class Base64StringVarExporter extends VarExporter {
    public function encodeString(string $var): string {
      // parent behavior is `return '"' . addslashes($var) . '"';
      return "base64_decode('" . base64_encode($var) . "')";
    }
}
</code>

Not the most performant thing, but extremely powerful.
</blockquote>

==== Dumping to a stream ====

https://externals.io/message/112924#112944
<blockquote>
> * You should drop the $return parameter and make it always return. As this is primarily an export and not a dumping function, printing to stdout doesn't make sense to me.

I'd argue the opposite. If dumping a particularly large tree of elements,
serializing that to a single string before then being able to write it to
file or wherever seems like packing on a lot of unnecessary effort. What I
would do is expand the purpose of the $output parameter to take a stream.
STDOUT by default, a file stream for writing to include files (one of the
more common uses), or even a tmpfile() if you do actually want it in a var.
</blockquote>

There's 3 drawbacks I don't like about that proposal:

  - If a function taking a stream were to throw or encounter a fatal error while converting an object to a stream, then you'd write an incomplete object to the stream or file, which would have to be deleted \\ E.g. internally, ''fprintf()'' and ''printf()'' calls ''sprintf'' before writing anything to the stream for related reasons.
  - This may be much slower and end users may not expect that - a lot of small stream writes with dynamic C function calls would be something I'd expect to take much longer than converting to a string then writing to the stream.  (e.g. I assume a lot of small echo $str; is much faster than ''\fwrite(\STDOUT, $str);'' in the internal C implementation) (if we call ''->serialize()'' first, then there's less of a reason to expose ''->serializeFile()'' and ''->serializeStream()'')
  - Adding even more ways to dump to a stream/file. Should that include stream wrappers such as http://?  For something like XML/YAML/CSV, being able to write to a file makes sense because those are formats many other applications/languages can consume, which isn't the case for var_export.
 
==== Changing var_dump ====

var_dump is a function which I consider to have goals that are incompatible ways.
If an exact representation of reference cycles, identical objects, and circular object data is needed, the code snippet ''unserialize("....")'' can be generated using ''var_representation(serialize($value))'' (or var_export).

In particular, var_dump() dumps object ids, indicates objects that are identical to each other, shows recursion, and shows the presence of references. It also redundantly annotates values with their types, and generates output for types that cannot be evaluated (e.g. ''resource(2) of type (stream)'').

Adding a comment such as ''/* resource(2) of type (stream) */ null'' to the var_representation output with an opt-in flag to add this information may be useful to explore in follow-up work.

https://externals.io/message/112967#112970

===== Changelog =====

  * 0.2: Add the section "When would a user use var_representation?". Add a comparison with other languages.
  * 0.3: Add more examples, add discussion section on indent
Page Tools
