DEV Community: NgeTech

Awesome! use Match Expression for simplify your code in PHP 8

NgeTech — Thu, 01 Aug 2024 23:23:54 +0000

PHP 8 introduces the match expression, which is a more powerful and concise alternative to the traditional switch statement.

The traditional switch statement requires break statements and can be more verbose.
The new match expression simplifies the syntax and returns a value directly.

for the example when we use switch case statement :

function getDayTypeWithSwitch(int $day): string
{
    switch ($day) {
        case 1:
        case 7:
            return 'weekend';
        case 2:
        case 3:
        case 4:
        case 5:
        case 6:
            return 'weekday';
        default:
            return 'unknown';
    }
}

echo getDayTypeWithSwitch(8); // Output: unknown
echo getDayTypeWithSwitch(7); // Output: weekend
echo getDayTypeWithSwitch(4); // Output: weekday

and the we comparing use match expression :

function getDayWithMatch(int $day): string
{
    return match ($day) {
        1, 7 => 'weekend',
        2, 3, 4, 5, 6 => 'weekday',
        default => 'unknown',
    };
}

echo getDayWithMatch(8); // Output: unknown
echo getDayWithMatch(7); // Output: weekend
echo getDayWithMatch(4); // Output: weekday

awesome you should be try it !

✅ 𝐁𝐞𝐧𝐞𝐟𝐢𝐭𝐬 𝐨𝐟 𝐔𝐬𝐢𝐧𝐠 𝐌𝐚𝐭𝐜𝐡 𝐄𝐱𝐩𝐫𝐞𝐬𝐬𝐢𝐨𝐧𝐬

👉 𝐂𝐨𝐧𝐜𝐢𝐬𝐞 𝐒𝐲𝐧𝐭𝐚𝐱: Reduces boilerplate code by eliminating the need for break statements.
👉 𝐑𝐞𝐭𝐮𝐫𝐧𝐬 𝐕𝐚𝐥𝐮𝐞𝐬: Can return values directly, making the code more expressive and functional.
👉 𝐒𝐭𝐫𝐢𝐜𝐭 𝐂𝐨𝐦𝐩𝐚𝐫𝐢𝐬𝐨𝐧𝐬: Uses strict comparisons (===) by default, avoiding type coercion issues.

By using match expressions in PHP 8, you can write cleaner, more efficient, and more readable code.

How do you like the new match expressions? Have you used them in your project yet? Share your experience in the comments below.

Pattern Matching for Switch in Java 21

NgeTech — Thu, 18 Jul 2024 06:52:43 +0000

Pattern matching has been a highly anticipated feature in Java, bringing more power and flexibility to the language. Java 21 introduces pattern matching for switch statements, which simplifies the code and reduces boilerplate. Let's explore how this new feature works and why it's beneficial.

What is Pattern Matching for Switch?

Pattern matching for switch allows you to match a value against patterns, making the code more expressive and readable. Instead of using multiple if-else statements or complex switch cases, you can now write more concise and maintainable code.

Benefits of Pattern Matching for Switch

Readability: Makes the code easier to read and understand.
Conciseness: Reduces the amount of boilerplate code.
Type Safety: Provides better type checking at compile time.

How to Use Pattern Matching for Switch

Here's a simple example to illustrate how pattern matching for switch works:

static String formatterPatternSwitch(Object obj) {
    return switch (obj) {
        case Integer i -> String.format("int %d", i);
        case Long l    -> String.format("long %d", l);
        case Double d  -> String.format("double %f", d);
        case String s  -> String.format("String %s", s);
        default        -> obj.toString();
    };
}

In this example, formatterPatternSwitch takes an Object and returns a formatted string based on its type. Here's a breakdown of what's happening:

Switch Expression: The switch expression takes the obj and matches it against different patterns.
Case Patterns: Each case specifies a pattern to match:
- Integer i: Matches if obj is an instance of Integer and binds the value to i.
- Long l: Matches if obj is an instance of Long and binds the value to l.
- Double d: Matches if obj is an instance of Double and binds the value to d.
- String s: Matches if obj is an instance of String and binds the value to s.
Default Case: The default case handles any values that do not match the specified patterns, converting them to a string using obj.toString().

Let's me give with detailed example case: Handling Different Shapes

Consider a scenario where you need to handle different shapes and calculate their areas. Here's how pattern matching for switch can simplify the code:

abstract sealed class Shape permits Circle, Square, Rectangle {}

final class Circle extends Shape {
    double radius;
    Circle(double radius) { this.radius = radius; }
}

final class Square extends Shape {
    double side;
    Square(double side) { this.side = side; }
}

final class Rectangle extends Shape {
    double length, width;
    Rectangle(double length, double width) { this.length = length; this.width = width; }
}

static double calculateArea(Shape shape) {
    return switch (shape) {
        case Circle c -> Math.PI * c.radius * c.radius;
        case Square s -> s.side * s.side;
        case Rectangle r -> r.length * r.width;
    };
}

In this example:

Sealed Classes: Shape is a sealed class, and only Circle, Square, and Rectangle can extend it.
Switch Expression: The calculateArea method uses a switch expression to determaine the type of shape and calculate its area.
Case Patterns: Each case matches a spesific shape type and performs the corressponding area calculation:
- Circle c: Matches if shape is a Circle and binds it to c, the calculates the area using c.radius
- Square s: Matches if shape is a Square and binds it to s, the calculates the area using s.side
- Rectangle r: Matches if shape is a Rectangle and binds it to r, the calculates the area using r.length and r.width.

Conclusion

Pattern matching for switch in Java 21 is a powerful feature that enhances code readability, conciseness, and type safety. By allowing you to match values against patterns directly in switch statements, it simplifies many common coding tasks. Java developers should definitely explore and adopt this feature to write cleaner and more maintainable code.

Feel free to modify or expand upon this section to suit your needs!

New in PHP 8! Simplify Your Code with the Nullsafe Operator

NgeTech — Sat, 06 Jul 2024 00:59:22 +0000

The Nullsafe operator, introduced in PHP 8.0, is a game-changer for handling nullable properties and method calls more gracefully. It allows you to avoid verbose null checks, making your code cleaner and more readable.

Example Tradition Null Check

$userCountry = null;
if ($user !== null) {
   if ($user->getAddress() !== null) {
      $userCountry = $user->getAddress()->getCountry();  
   }
}

𝐖𝐡𝐲 𝐔𝐬𝐞 𝐭𝐡𝐞 𝐍𝐮𝐥𝐥𝐬𝐚𝐟𝐞 𝐎𝐩𝐞𝐫𝐚𝐭𝐨𝐫?

✅ 𝐂𝐨𝐧𝐜𝐢𝐬𝐞𝐧𝐞𝐬𝐬: Reduces the amount of boilerplate code required for null checks.
✅ 𝐑𝐞𝐚𝐝𝐚𝐛𝐢𝐥𝐢𝐭𝐲: Makes your code more readable and expressive, clearly showing the intent of handling nullable values.
✅ 𝐒𝐚𝐟𝐞𝐭𝐲: Helps avoid null dereference errors in a more elegant way, ensuring your code handles potential null values seamlessly.

Nullsafe implementation

$userCountry = $user?->getAddress()?->getCountry();

Have you started using the Nullsafe operator in your PHP 8 projects? Share your thoughts and experiences!

Use an Object Literal, Better than Using Conditional Statements in JavaScript

NgeTech — Fri, 28 Jun 2024 09:20:55 +0000

Conditional Statements (If-Else, Switch) can be easily replaced with Object Literals. They make the code better.

Object Literals

An Object Literal is one of the most popular and widely used pattern to define objects in JavaScript. It is a collection of key-value pairs. JavaScript being powerful, adds some additional functionalities to the simple objects through object literals.

const obj = {
   first_name: 'Irpan',
   last_name: 'Abdul Rahman'
}
// An example of an object literal

How can we use Object Literal as a replacement to Conditional Statements?

Let us consider an example scenario to understand this.

A user enters an animal, we need to return the name of its baby (what is is called).

Look at the following codes:

//if conditional
if(animal.toLowerCase()==='cat'){
    return 'Kitten'
} else if(animal.toLowerCase()=='cattle'){
     return 'Calf'
} else if(animal.toLowerCase()==='cheetah'){
     return 'Cub';
} else if(animal.toLowerCase()==='dog'){
     return 'Pup';
} else{
   return "I don't know that"
}

//switch case
switch(animal.toLowerCase()){
   case 'cat': return 'Kitten'
   case 'cattle': return 'Calf'
   case 'cheetah': return 'Cub'
   case 'dog': return 'Pup'
   default: return "I don't know that"
}

The above codes have many lines as we can see. No matter if we write it using if-else or switch case, though switch case reduces the redundant ‘animal.toLowerCase()’.

const babyAnimal = {
   cat:'Kitten',
   cattle:'Calf',
   cheetah:'Cub',
   dog:'Pup'
}
return babyAnimal[animal.toLowerCase()] ?? "I don't know that"

Now, this code works exactly same as the above two codes do. But the difference is that it looks neater and has lesser conditions to check thereby reducing the load time.

I think it’s pretty nice to use this wherever possible. Any thoughts on this? please comment bellow.

credit cover images by Markus Spiske on Unsplash