Forem: Aju Chacko

Object.defineProperty call replaces the setter with a normal data property.

Aju Chacko — Wed, 16 Apr 2025 07:26:53 +0000

set prop1(name) {
  console.log('Hey there!');
}

Object.defineProperty(obj, 'prop1', {
  value: 'secret',
  writable: true,
  configurable: true,
  enumerable: true
});

This call overwrites the prop1 accessor property with a data property. That means the setter is gone.

Now obj.prop1 is just a string "secret" (and later "hello"), so assigning a new value simply sets the value — no function is called.

In addition, Object.defineProperty() uses the [[DefineOwnProperty]] internal method, instead of [[Set]], so it does not invoke setters, even when the property is already present.

PHP8 (quick note)

Aju Chacko — Wed, 13 May 2020 19:14:58 +0000

Union types

Union types are a collection of two or more types which indicate that either one of those can be used.

void can never be part of a union type, since it indicates "no return value at all". Furthermore, nullable unions can be written using |null, or by using the existing ? notation:

public function foo(Foo|Bar $input): int|float;

public function foo(Foo|null $foo): void;

public function bar(?Bar $bar): void;

JIT

The JIT — just in time — compiler promises significant performance improvements, albeit not always within the context of web requests.

Attributes

Attributes, commonly known as annotations in other languages, offers a way to add meta data to classes, without having to parse docblocks.

<<Attribute>>
class ExampleAttribute
{
    public $value;

    public function __construct($value)
    {
        $this->value = $value;
    }
}

use App\Attributes\ExampleAttribute;

<<ExampleAttribute>>
class Foo
{
    <<ExampleAttribute>>
    public const FOO = 'foo';

    <<ExampleAttribute>>
    public $x;

    <<ExampleAttribute>>
    public function foo(<<ExampleAttribute>> $bar) { }
}

static return type

class Foo
{
    public function test(): static
    {
        return new static();
    }
}

mixed type

Note that mixed can also be used as a parameter or property type, not just as a return type.

Throw expression

throw from being a statement to being an expression,

$triggerError = fn () => throw new MyError();

$foo = $bar['offset'] ?? throw new OffsetDoesNotExist('offset');

Weak maps

a WeakMap implementation is added in PHP 8. WeakMaps hold references to objects, which don't prevent those objects from being garbage collected.

::class on objects

::class on objects, instead of having to use get_class() on them.

$foo = new Foo();

var_dump($foo::class);

Non-capturing catches

to catch an exception before PHP 8, you had to store it in a variable, regardless whether you used that variable or not. With non-capturing catches, you can omit the variable, so instead of this:

try {
    // Something goes wrong
} catch (MySpecialException $exception) {
    Log::error("Something went wrong");
}

try {
    // Something goes wrong
} catch (MySpecialException) {
    Log::error("Something went wrong");
}

Trailing comma in parameter lists

public function(
    string $parameterA,
    int $parameterB,
    Foo $objectfoo,
) {
    // …
}

Stringable interface

The Stringable interface can be used to type hint anything that is a string or implements __toString(). Furthermore, whenever a class implements __toString(), it automatically implements the interface behind the scenes and there's no need to manually implement it.


class Foo
{
    public function __toString(): string
    {
        return 'foo';
    }
}

function bar(Stringable $stringable) { /* … */ }

bar(new Foo());
bar('abc');

str_contains() function

if (str_contains('string with lots of words', 'words')) { /* … */ }

str_starts_with() and str_ends_with() functions

str_starts_with('haystack', 'hay'); // true
str_ends_with('haystack', 'stack'); // true

Arrow➡️ functions in php

Aju Chacko — Wed, 13 May 2020 15:42:05 +0000

There is a new feature in php 7.4 added called short closures or arrow functions. Below is an example of array_map() with closure and new syntax. It is much neater related to using closure when passing to functions like array_map and array_filter.

$ids = array_map(function ($post) {
    return $post->id;
}, $posts);

// A collection of Post objects
$posts = [/* … */];

$ids = array_map(fn($post) => $post->id, $posts);

// with type hinting
$ids = array_map(fn(Post $post): int => $post->id, $posts);

// to return a value by reference,
fn&($x) => $x

They only allow one expression; that one expression can be spread over multiple lines for formatting.

Another significant difference between short and normal closures is that the short ones don't require the use keyword to be able to access data from the outer scope.

$modifier = 5;

array_map(fn($x) => $x * $modifier, $numbers);

// OR

$x = 1;
$fn = fn() => $x++; // Has no effect
$fn();
var_export($x);  // Outputs 1

variables from the outer scope. Values are bound by value and not by reference.

array deStructure

Aju Chacko — Wed, 13 May 2020 09:48:48 +0000

The short array syntax([]) is a language construct just like array(). This can be used to take variables out of an array. I mean to "destructure" the array into separate variables.

$array = ['a', 'b', 'c']; 

// Using the list syntax:
list($a, $b, $c) = $array;

// Or the shorthand syntax:
[$a, $b, $c] = $array;

// $a = 'a'
// $b = 'b'
// $c = 'c'

Suppose you only needed the last element of an array, the first two can be skipped by simply not providing a variable.

[, , $c] = $array;

// $c = 'c'

Also note that list will always start at index 0. Take for example the following array:

$array = [
    1 => 'a',
    2 => 'b',
    3 => 'c',
];

[$a, $b, $c] = $array;
echo $a;
// Notice: Undefined offset: 0

[ , $a, $b, $c] = $array;
echo $a;
// 'a'

The first variable pulled out with list would be null, because there's no element with index 0. This might seem like a shortcoming, but luckily there are more possibilities.

PHP 7.1 allows list to be used with arrays that have non-numerical keys. This opens a world of possibilities.

$array = [
    'a' => 1,
    'b' => 2,
    'c' => 3,
];

['c' => $c, 'a' => $a] = $array;

foreach ($array as ['id' => $id, 'name' => $name]) {
    // …
}

ENUM IN PHP

Aju Chacko — Tue, 12 May 2020 17:56:52 +0000

Enum is the short form for an enumeration type, we use it to group named values. Enums are used instead of strings to denote the status of objects in an organised way. Unfortunately PHP doesn't have a native enum type. Although it offers a basic SPL implementation.

class Day extends SplEnum {    
    const MONDAY    = 1;
    const TUESDAY   = 2;
    const WEDNESDAY = 3;
    const THURSDAY  = 4;
    const FRIDAY    = 5;
    const SATURDAY  = 6;
    const SUNDAY    = 7;
}

echo new Day(Day::MONDAY);

try {
    new Day('UnknownDay');
} catch (UnexpectedValueException $e) {
    echo $e->getMessage();
}

// RESULT
// 1
// Value not a const in enum Day

Better Version

Imagine we need to store Payment in a database, with its status represented as a string we could do it like this.

class Payment
{
    public function setStatus(string $status)
    {
        $this->status = $status;
    }
}

class PaymentStatus extends Enum
{
    const INITIATED = 'initiated';
    const PENDING   = 'pending';
    const COMPLETED = 'completed';
    const FAILED    = 'failed';
}

// ...

$payment->setStatus(PaymentStatus::COMPLETED);

This won't be doing any type checking so any string value can be passed to "setStatus()" method. There is a good package in php my Matthieu Napoli called myclabs/php-enum.

Solution

class Payment
{
    public function setStatus(PaymentStatus $status)
    {
        $this->status = $status;
    }
}

// ...

$payment->setStatus(PaymentStatus::COMPLETED());

Calling the PaymentStatus constant statuses as a method creates a new instance of PaymentStatus using php magic method __callStatic() with an attribute value of 'completed'. Now we can type check for PaymentStatus and ensure the input is one of the four things defined by the "enum".

php RFC:__toArray()

Aju Chacko — Mon, 11 May 2020 11:53:25 +0000

This is a new RFC under discussion, proposed for php version 8. It is to add a new magic method called __toArray() to allow a class to control how it is represented when converted to an array.

class Person
{
    protected $name;
    protected $email;

    public $another = 'value';

    public function __construct(string $name, string $email)
    {
        $this->name = $name;
        $this->email  = $email;
    }

    public function __toArray()
    {
        return [
            'name' => $this->name,
            'email'  => $this->email,
        ];
    }
}

$person = new Person('John Doe', 'jon@example.com');

$personArray = (array) $person; // casting triggers __toArray()
# Result
/*
 [
   "name" => "John Doe",
   "email" => "jon@example.com"
 ]
*/

Calling any objects implemented __toArray() magic method on any array context including type hinting(only when using weak typing) and return types can get array version of the object.

Usage

function foo(array $person) {
    print_r($person);
}

// Output
/*
[
  "name" => "John Doe"
  "email"=> "jon@example.com"
}
*/

function bar(Person $person): array {
    return $person;
}

print_r(bar($person));

// Output
/*
[
  "name" =>"John Doe"
  "email"=>"jon@example.com"
]
*/

declare(strict_types=1);

function bar(Person $person): array {
    return (array) $person;
}

/*
[
  "name" =>"John Doe"
  "email"=>"jon@example.com"
]
*/
 // Note: without the array type casting before return would trigger an error here.

This is similar to PHP's current implementation of __toString(),
a copy of the given object's value as an array
is made upon conversion.

However this proposal does not allow accessing and setting values as you would in a normal array, that functionality remains with classes implementing the ArrayAccess interface.

For more information take a look at the RFC