First-class callable syntax in PHP - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a first-class callable from the function strlen.

PHP

<?php
$func = [1](...);
echo $func('hello');
?>

Drag options to blanks, or click blank then click option'

Astrlen()

Bstrlen

C'strlen'

D&strlen

Attempts:

3 left

💡 Hint

Common Mistakes

Using quotes around the function name creates a string, not suitable for first-class syntax.

Adding parentheses calls the function immediately instead of creating a callable.

In PHP 8.1+, to create a first-class callable from a function, use the function name without quotes or parentheses, followed by (...).

2fill in blank

medium

Complete the code to create a first-class callable from the function strtoupper using the callable syntax.

PHP

<?php
$func = [1](...);
echo $func('hello');
?>

Drag options to blanks, or click blank then click option'

Astrtoupper

B&strtoupper

Cstrtoupper()

D'strtoupper'

Attempts:

3 left

💡 Hint

Common Mistakes

Using quotes or parentheses instead of just the function name.

Trying to use the address-of operator (&) which is not valid here.

The first-class callable syntax for functions uses just the function name without quotes or parentheses, followed by (...).

3fill in blank

hard

Complete the code to create a first-class callable from the static method MyClass::myMethod.

PHP

<?php
class MyClass {
    public static function myMethod() {
        return 'Hello';
    }
}

$callable = [1](...);
echo $callable();
?>

Drag options to blanks, or click blank then click option'

AMyClass::myMethod

B'MyClass::myMethod'

C'MyClass::myMethod()'

DMyClass::myMethod()

Attempts:

3 left

💡 Hint

Common Mistakes

Using quotes creates an old-style string callable.

Adding parentheses calls the method immediately instead of creating a callable.

For static methods, the first-class callable syntax uses the class name, ::, and method name without quotes or parentheses, followed by (...).

4fill in blank

hard

Fill both blanks to create a first-class callable from an instance method myMethod of $obj.

PHP

<?php
class MyClass {
    public function myMethod() {
        return 'Hi';
    }
}
$obj = new MyClass();
$callable = [1]->[2](...);
echo $callable();
?>

Drag options to blanks, or click blank then click option'

A$obj

B'myMethod'

CmyMethod

D'MyClass::myMethod'

Attempts:

3 left

💡 Hint

Common Mistakes

Using quotes around the method name (use bare identifier).

Using the class name instead of the object variable.

To create a first-class callable for an instance method, use $object->method(...) with the bare method name (no quotes).

5fill in blank

hard

Fill all three blanks to create a first-class callable from a closure stored in $closure and call it with argument 'world'.

PHP

<?php
$closure = fn($name) => "Hello, $name!";
$callable = [1];
echo $callable([2]);

// Using first-class callable syntax
$callable2 = [3];
echo $callable2('world');
?>

Drag options to blanks, or click blank then click option'

A$closure

B'world'

C$closure(...)

Dclosure

Attempts:

3 left

💡 Hint

Common Mistakes

Trying to quote the closure variable name.

Not using quotes for the string argument.

Forgetting the spread operator (...) for first-class syntax.

Assign the closure variable directly as it's already callable. Call it with the string argument. Use $closure(...) for explicit first-class callable syntax.

Practice

1. What does the first-class callable syntax in PHP allow you to do?

easy

A. Automatically convert functions to strings

B. Create new functions dynamically at runtime

C. Prevent functions from being called more than once

D. Treat functions as variables to pass or store them easily

Solution

1. Step 1: Understand the concept of first-class callables

   First-class callable syntax lets you treat functions like variables, so you can pass or store them.

2. Step 2: Compare options with this concept

   Only 'Treat functions as variables to pass or store them easily' correctly describes this ability; others describe unrelated features.

3. Final Answer:

   Treat functions as variables to pass or store them easily -> Option D

4. Quick Check:

   First-class callable = Treat functions as variables [OK]

Hint: Remember: first-class means functions act like variables [OK]

Common Mistakes:

• Confusing callable syntax with dynamic function creation
• Thinking it converts functions to strings
• Assuming it restricts function calls

2. Which of the following is the correct syntax to get a first-class callable for a function named foo in PHP?

easy

A. $callable = foo(...);

B. $callable = foo();

C. $callable = foo\(...);

D. $callable = foo;

Solution

1. Step 1: Recall the first-class callable syntax

   In PHP, to get a callable for a function, you use function_name(...).

2. Step 2: Match the syntax with options

   $callable = foo(...); uses foo(...), which is correct. $callable = foo(); calls the function. foo\(...) uses backslash incorrectly causing syntax error. $callable = foo; treats name as constant.

3. Final Answer:

   $callable = foo(...); -> Option A

4. Quick Check:

   Callable syntax = function_name(...) [OK]

Hint: Use parentheses with ellipsis to get callable: foo(...) [OK]

Common Mistakes:

• Calling the function instead of getting callable
• Omitting parentheses and ellipsis
• Using backslash incorrectly for global functions

3. What will be the output of the following PHP code?

$fn = strlen(...);
echo $fn('hello');

medium

A. 5

B. hello

C. strlen

D. Error: Call to undefined function

Solution

1. Step 1: Understand the callable assignment

   The variable $fn is assigned the callable for the built-in function strlen using first-class callable syntax.

2. Step 2: Call the callable with argument 'hello'

   Calling $fn('hello') executes strlen('hello'), which returns 5.

3. Final Answer:

   5 -> Option A

4. Quick Check:

   strlen('hello') = 5 [OK]

Hint: Callable with strlen(...) returns string length [OK]

Common Mistakes:

• Expecting the function name as output
• Confusing callable with string
• Thinking it causes an error

4. Identify the error in the following PHP code using first-class callable syntax:

function greet($name) {
    return "Hello, $name!";
}

$greet = greet;
echo $greet('World');

medium

A. No error, code runs fine

B. Missing parentheses and ellipsis to get callable

C. Cannot assign function to variable

D. Function greet is not defined

Solution

1. Step 1: Check how callable is assigned

   The code assigns $greet = greet; which is invalid syntax for first-class callable.

2. Step 2: Correct syntax requires parentheses and ellipsis

   To get a callable, it should be $greet = greet(...);. Without this, PHP treats it as a constant or causes error.

3. Final Answer:

   Missing parentheses and ellipsis to get callable -> Option B

4. Quick Check:

   Callable syntax needs (...) [OK]

Hint: Always use (...) to get callable, not just function name [OK]

Common Mistakes:

• Assigning function name without parentheses
• Assuming function name alone is callable
• Ignoring syntax errors

5. Given the following PHP code, what will be the output?

function multiply($a, $b) {
    return $a * $b;
}

$operations = [
    'double' => multiply(...),
    'square' => fn($x) => multiply($x, $x),
];

echo $operations['double'](5, 2) . ', ' . $operations['square'](4);

hard

A. Error: Cannot use multiply(...) here

B. 7, 16

C. 10, 16

D. 10, 8

Solution

1. Step 1: Understand the callable assignments

   The array $operations stores two callables: 'double' uses first-class callable multiply(...), 'square' uses an arrow function calling multiply.

2. Step 2: Evaluate each callable call

   $operations['double'](5, 2) calls multiply(5, 2) = 10.
   $operations['square'](4) calls multiply(4, 4) = 16.

3. Final Answer:

   10, 16 -> Option C

4. Quick Check:

   multiply(5,2)=10 and multiply(4,4)=16 [OK]

Hint: First-class callable works inside arrays like normal functions [OK]

Common Mistakes:

• Confusing arrow function with callable syntax
• Expecting error from multiply(...) usage
• Mixing up multiply arguments