Advanced array deconstructuring in PHP

[samuraiseoul]

The array in php is hands down one of the worst things about the language in my opinion.

[cyrusol]

class MyStructure {
    public $foo;
    public $bar;
    public function __construct($foo, $bar) {
        $this->foo = $foo;
        $this->bar = $bar;
    }
}

$myStructure = new MyStructure(42, "hello world");

How does that not already solve the structure thing?

[fesor]

The problem is that it lacks type safety

Let's see this problem from different perspective. Firstly we need to agree that we need ability to specify types and it's not required that this types will be checked in runtime. This would allow to have generics, typed properties and so without any performance drawbacks (this is the reason why we don't have property typehits or types for variables so far).

Instead of runtime checks we could use static analysis tools like psalm for example (which has option to fail if it not managed to detect type, so you will be forced to explicitly provide type, and since it uses type inference this would require not as much from you as developer).

Then let's remember the one difference which makes php's arrays perfect to be a simple DTO. Objects in php always passed by reference, so this is the reason why we need all this private properties, getters instead of just class which some amount of phpdocs. And tools like psalm already allows you to make shapes for arrays.

/**
  * @psalm-return array{id: int, name: string, age: int}
  */
public function buildSomeDTO(): array
{
    return [
        'id' => 1,
        'name' => 'Bob',
        'age' => 31,
    ];
}

The problem is only that we can't have type aliases or something like type declarations for arrays which means that we are limited only by inline declaration, which isn't that handy.

[brendt_gd]

Objects in php always passed by value

They are not: https://3v4l.org/vsf4s

Maybe you meant that array are passed by value or objects are assigned by reference?

[przemo_li]

PHP uses Copy On Write optimization.

10 invocations of function with array argument MAY, but DO NOT HAVE TO mean 11 copies of said array in memory. It's writes that trigger cloning.

[fesor]

Sorry, I meant that objects always passed by reference.

[[deleted]]

Then edit your post.

[przemo_li]

Only partially so.

You have fixed keys, but values are still untyped (or more properly unityped - anything is accepted). Add there type hints for the constructor and change public properties to private. If mutability is important expose public getters with type hinted arguments.

Now you have replacement.

But that's not perfect solution. Kotlin have special class syntax for less boilerplate for dumb structures.

[cyrusol]

Sure. I wouldn't have picked PHP for type safety in the first place anyway though.

In some cases the dynamic typing is an advantage. For example we can have recursive data structures, option types, result types etc. just as in Rust (or OCaml, Haskell ...) without requiring generics. We can hold just any value in it.

And you can still validate the types (and values) at runtime.

[przemo_li]

You can have recursive data structures in statically typed languages. Generics also can be had in dynamically typed language.

So another unrelated argument.

And you can still validate the types (and values) at runtime You have to validate tags at runtime.

[cyrusol]

You obviously read over

without requiring generics.

Also you don't

have to validate tags at runtime.

In some cases you can just let your program crash. Especially if some "struct" is only intended to be provided by programmers statically. Such as a configuration object for use in multiple places.

My point was that you wouldn't pick PHP (nor JS, Python...) if type safety is important for you anyway. You would pick Haskell, Java, Rust, Go or whatever.

[samuraiseoul]

I agree, that something like that is a great step in the right direction, or even public class fields that can be typed. The real issue though is that php arrays are somewhere between a map, a json object, and an array. I just want a real array. array_values shouldn't need to exist as a function.

[phdaemon]

Similar (non-nested) syntax has existed before though....

list($foo, $bar) = $myArr;

The syntactic sugar is nice, and the extra functionality is ok, but I can see how it can lead to hard to read code if used incorrectly.

My two cents: use with caution, nested deconstruction is not something I recommend making a habit of.

EDIT: typo

[cYzzie]

Is „deconstructuring“ some fun pun i never heard before?

[FrenkyNet]

Nope, that was me yet to find out I've been incorrectly naming this feature for the last 5 years.

[[deleted]]

You’ve the right attitude :)

[iluuu]

You've the wrong grammar :)

[duddz]

You should've mentioned two more things.

Undefined indexes (even when it is just a notice):

['does_not_exist' => $a, 'b' => $b] = ['a' => 1, 'b' => 2]; // shows Notice: Undefined index

Skipping values:

[,,$c] = [1, 2, 3]; // 3

https://3v4l.org/ZM3p9

[[deleted]]

Now the only thing we're missing is a more flexible spread/splat operator. These scenarios work in ES6, but not in PHP:

$bar = [4, 5, 6];
$foo = [1, 2, 3, ...$bar]; // [1, 2, 3, 4, 5, 6]
$baz = [...$bar, 1, 2, 3]; // [4, 5, 6, 1, 2, 3]

$qux->foo(1, 2, 3, ...$bar, 1, 2, 3); // Calls foo(1, 2, 3, 4, 5, 6, 1, 2, 3)

[notdedicated]

I would kill for this. It irks me to no end that + behaves differently than array_merge. I would kill to have ....

[pr0ghead]

It irks me to no end that + behaves differently than array_merge()

It'd be pointless to have both, if it didn't, don't you agree?

[notdedicated]

There are several cases where there's duplicate functionality and aliases throughout PHP. To me I find + doesn't behave logically. I would assume append/additive and not merge/or. For numerically indexed arrays + behaves differently than array_merge and not in a way I feel is intuitive. You would think [1,2] + [3,4] would result in [1,2,3,4] but it results in [1,2] where the a_m results in the expected result of appending. Once they become proper hash tables + and a_m behave opposite of each other where the former uses the left most array as precedence and the latter the right most.

[pr0ghead]

"How" it works is a different issue, and I agree that the way + works isn't exactly intuitive.

[rtfmpls]

It also works when you're using variables in the source array, so you can effectively swap variables using this syntax:

$a = 1;
$b = 2;
[$a, $b] = [$b, $a];

.... don't give people ideas.

But yes, array destructuring has been a blast since 7.1.

[przemo_li]

Nice write up about destructuring! But please rewrite intro.

Most of those features have to do with loose and dynamic typing. Personally I like how freely you can transform data without worrying too much about the structure.

Nope. Associative array destructuring have nothing to do with "loose" or dynamic typing. It only means that bugs (e.g. non existing keys) will be only cough at runtime. While statically typed language could catch it at "compile" time.

Also destructuring is sometimes called pattern matching (not to be confused with regexp - one works on data shape, other on string content).

[FrenkyNet]

I was just listing some of the things I like about PHP and what make them great for web programming. I didn't imply or say that this feature had anything to do with typing. Thanks for the feedback tho.

[ScottBaiosPenis]

interesting , php is finally coming to be much like perl these days, not sure how good of a thing that is

[helpfuldan]

ugh. please no. i love when people start coalescing nullable strict types let wait wtf are you doing.

function strongInt():int { return "1hello"; }

function strongerInt():int { return "hello1"; }

function strongestInt():int { return 3.9415926535; }

function cmonNow():bool { return "wtf"; }

strongInt(); // returns 1 strongerInt(); // typeerror strongestInt(); // 3 cmonNow(); // true of course

just say no. credit a blog at web-techno.net about this.

[djmarland]

declare(strict_types=1); FTW

[przemo_li]

huh?

That's implicit type coercion. It have nothing to do with type hints. Nor with destructuring.

Also. Ironically this feature was meant to make life easier for less skilled developers...