DEV Community: Moataz khaled

Elevating Laravel Development with the Singleton Design Pattern

Moataz khaled — Sat, 03 Aug 2024 00:32:15 +0000

As a Team Lead at Lamasatech, I constantly seek ways to enhance our software architecture and development processes. One design pattern that has proven indispensable in achieving robust and maintainable code is the Singleton Design Pattern.
Understanding the Singleton Design Pattern

The Singleton Design Pattern ensures that a class has only one instance and provides a global point of access to that instance. This pattern is particularly beneficial in scenarios where a single point of control is needed, such as in managing shared resources.
Why Implement Singleton in Laravel?

Service Container: Laravel’s service container allows for managing class dependencies efficiently. By binding a class as a singleton, Laravel ensures a single instance is used throughout the application, promoting consistency and resource efficiency.
Configuration Management: Centralizing configuration settings through a singleton ensures that all parts of the application access the same configuration instance, maintaining uniformity.
Logging: Implementing a singleton logging service ensures that logs are handled by a single, consistent instance, simplifying log management.
Cache Management: A singleton cache manager ensures a unified and consistent caching mechanism across the application.

Implementing Singleton in Laravel

Laravel simplifies the implementation of singletons through its service container. Here’s how to bind a class as a singleton in Laravel:

namespace App\Providers;

use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    public function register()
    {
        $this->app->singleton('SomeService', function ($app) {
            return new \App\Services\SomeService();
        });
    }
}

In this setup, the SomeService class is instantiated only once, and the same instance is used for subsequent calls.
Practical Example: Logging Service

Consider a logging service you want to use throughout your Laravel application. By binding it as a singleton, you ensure all parts of your application use the same logging instance, thereby simplifying log management:

namespace App\Services;

class LoggingService
{
    public function log($message)
    {
        // Log message to a file or database
    }
}

// In AppServiceProvider
$this->app->singleton('LoggingService', function ($app) {
    return new \App\Services\LoggingService();
});

// Usage in a controller
public function index(\App\Services\LoggingService $loggingService)
{
    $loggingService->log('This is a log message.');
}

By leveraging the Singleton Design Pattern in Laravel, we can create more maintainable, efficient, and scalable applications. Whether you're a budding developer or a seasoned architect, mastering design patterns like Singleton is crucial for advancing your coding expertise.

How do you utilize the Singleton Design Pattern in your Laravel projects? Share your experiences and insights in the comments below!

Laravel #SoftwareDevelopment #DesignPatterns #Singleton #CodingTips #PHP #SoftwareEngineering #TechLeadership #CleanCode

TERMINAL COMMAND LINE ORDERS

Moataz khaled — Wed, 21 Jun 2023 19:19:19 +0000

✨Let's explore some background on the terminal🏃‍♂️🏃‍♂️🏃‍♂️....
What is the terminal?
Terminal is an application that lets you interact with your computer.You usually give instructions to your computer through clicking around in applications or typing keys to make
things happen.
Terminal lets you do many of the same things; it’s just
more direct. You can give clear, structured orders to your computer using the terminal.
You just have to be patient and willing to try them!
"Where am I?" in my computer
When you first launch Terminal, you'll likely have an empty window with not much going on. My Terminal window looks like this, but yours is probably a different color or set of text on the left (which is fine!)
I see a simple dollar sign and a blinking cursor, but you might see the name of your computer too or other symbols:
💁💁💁..
*Run this command *

pwd

Finding destinations

In your computer, you can go pretty much anywhere you want. First, though, you must know the destinations available to you.
On the command line, type the following command (ls , which is short for list), and press the Enter key on your keyboard.
*Run this command *

ls

Going to destinations

Now that you've revealed possible directories (folders) available to you, you can move around them using a different command:cd which is short for "change directory," plus the name of the folder where you want to move.
For example, let's say I want to change locations in my system and move into the "Music" folder. This was listed as one of the options in the output from our ls command. I'd type:



    cd Music

Here's what my Terminal looks like after running cd Music:

Create directory

It's now time to create a folder within your system.
Yes, you could just do this via Finder or whatever tool you use to browse and create files now. However, there are advantages to doing this via the terminal, especially if you want to get more into programming!
How does one go about creating a folder in Terminal? Time for a new command!
Use the command mkdir to create a directory. mkdir is short for "make directory." Specify the name of the directory (folder) you want to create just after it. If I wanted to create a folder called new-folder , I would run:



    mkdir new-folder

Move File
if you want to move file in the same path or another directory



mv fileName  /temp/fileName

copy File
if you want to cope file in the same path or another directory



cp fileName  newfileName

Remove File
if you want to remove file in the same path or another directory



rm fileName

Remove folders
if you want to remove folders in the same path or another directory



rmdir folderName

I have a question!

Moataz khaled — Thu, 19 May 2022 00:13:34 +0000

I have a question! design patterns and SOLID principles are the perfect way to use enhancement performance and clean code
when searching for design patterns I found this question
Why Are Singletons Bad?
when I read the article I found him opinion's true
so I want to open a discussion on this point
design patterns and SOLID principles are the perfect or not?
start with Singletons design patterns
#design_patterns

SOLID

Why used "explain" in MYSQL ?

Moataz khaled — Thu, 02 Dec 2021 12:22:44 +0000

Explain

The EXPLAIN statement provides information about how MySQL executes statements
works with SELECT, DELETE, INSERT, REPLACE, and UPDATE statements.
is used with an explainable statement, MySQL displays information from the optimizer about the statement execution plan.

How to used Explain

This section describes the output columns produced by EXPLAIN. Later sections provide additional information about the type and Extra columns.

EXPLAIN Join Types

The type column of EXPLAIN output describes how tables are joined. In JSON-formatted output, these are found as values of the access_type property. The following list describes the join types, ordered from the best type to the worst:

system

The table has only one row (= system table). This is a special case of the const join type.

const

The table has at most one matching row, which is read at the start of the query. Because there is only one row, values from the column in this row can be regarded as constants by the rest of the optimizer. const tables are very fast because they are read only once.

const is used when you compare all parts of a PRIMARY KEY or UNIQUE index to constant values. In the following queries, tbl_name can be used as a const table

   `SELECT * FROM tbl_name WHERE primary_key=1;

   SELECT * FROM tbl_name
    WHERE primary_key_part1=1 AND primary_key_part2=2;`

eq_ref

One row is read from this table for each combination of rows from the previous tables. Other than the system and const types, this is the best possible join type. It is used when all parts of an index are used by the join and the index is a PRIMARY KEY or UNIQUE NOT NULL index.

eq_ref can be used for indexed columns that are compared using the = operator. The comparison value can be a constant or an expression that uses columns from tables that are read before this table. In the following examples, MySQL can use an eq_ref join to process ref_table:
`SELECT * FROM ref_table,other_table
WHERE ref_table.key_column=other_table.column;

    SELECT * FROM ref_table,other_table
      WHERE ref_table.key_column_part1=other_table.column
      AND ref_table.key_column_part2=1;`

ref

All rows with matching index values are read from this table for each combination of rows from the previous tables. ref is used if the join uses only a leftmost prefix of the key or if the key is not a PRIMARY KEY or UNIQUE index (in other words, if the join cannot select a single row based on the key value). If the key that is used matches only a few rows, this is a good join type.

ref can be used for indexed columns that are compared using the = or <=> operator. In the following examples, MySQL can use a ref join to process ref_table:
`SELECT * FROM ref_table WHERE key_column=expr;

     SELECT * FROM ref_table,other_table
       WHERE ref_table.key_column=other_table.column;

       SELECT * FROM ref_table,other_table
   WHERE ref_table.key_column_part1=other_table.column
      AND ref_table.key_column_part2=1;`

fulltext

The join is performed using a FULLTEXT index.

ref_or_null

This join type is like ref, but with the addition that MySQL does an extra search for rows that contain NULL values. This join type optimization is used most often in resolving subqueries. In the following examples, MySQL can use a ref_or_null join to process ref_table:
SELECT * FROM ref_table WHERE key_column=expr OR key_column IS NULL;

index_merge

This join type indicates that the Index Merge optimization is used. In this case, the key column in the output row contains a list of indexes used, and key_len contains a list of the longest key parts for the indexes used. For more information, see Section 8.2.1.3, “Index Merge Optimization”.

unique_subquery

This type replaces eq_ref for some IN subqueries of the following form:
value IN (SELECT primary_key FROM single_table WHERE some_expr)

index_subquery

This join type is similar to unique_subquery. It replaces IN subqueries, but it works for nonunique indexes in subqueries of the following form:
value IN (SELECT key_column FROM single_table WHERE some_expr)

range

Only rows that are in a given range are retrieved, using an index to select the rows. The key column in the output row indicates which index is used. The key_len contains the longest key part that was used. The ref column is NULL for this type.

range can be used when a key column is compared to a constant using any of the =, <>, >, >=, <, <=, IS NULL, <=>, BETWEEN, LIKE, or IN() operators:

   `SELECT * FROM tbl_name
      WHERE key_column = 10;

    SELECT * FROM tbl_name
      WHERE key_column BETWEEN 10 and 20;

    SELECT * FROM tbl_name
      WHERE key_column IN (10,20,30);

    SELECT * FROM tbl_name
      WHERE key_part1 = 10 AND key_part2 IN (10,20,30);`

index

The index join type is the same as ALL, except that the index tree is scanned. This occurs two ways:

If the index is a covering index for the queries and can be used to satisfy all data required from the table, only the index tree is scanned. In this case, the Extra column says Using index. An index-only scan usually is faster than ALL because the size of the index usually is smaller than the table data.

A full table scan is performed using reads from the index to look up data rows in index order. Uses index does not appear in the Extra column.

MySQL can use this join type when the query uses only columns that are part of a single index.

*ALL
*
A full table scan is done for each combination of rows from the previous tables. This is normally not good if the table is the first table not marked const, and usually very bad in all other cases. Normally, you can avoid ALL by adding indexes that enable row retrieval from the table based on constant values or column values from earlier tables.

Types of Array in PHP

Moataz khaled — Mon, 26 Jul 2021 19:12:21 +0000

We have three types of array :

Indexed Array

An array with a numeric key is known as the indexed array. Values are stored and accessed in linear order.

Associative Array

An array with strings for indexing elements is known as the associative array. Element values are stored in association with key values rather than in strict linear index order.

Multidimensional Array

An array containing one or more arrays within itself is known as a multidimensional array. The values are accessed using multiple indices.

PHP 8 & PHP 7

Moataz khaled — Thu, 08 Apr 2021 21:42:39 +0000

Constructor property promotion

PHP 7

 class Point {

public float $x;
public float $y;
public float $z;

public function __construct(float $x = 0.0, float $y = 0.0, float $z = 0.0) {
    $this->x = $x;
    $this->y = $y;
    $this->z = $z;
}

}

PHP 8

class Point {

  public function __construct(public float $x = 0.0,public float $y = 0.0,public float $z = 0.0,) {

  }

 }

How to write clean code.

Moataz khaled — Thu, 08 Apr 2021 12:09:59 +0000

Good code

At some time we write if statement like:

public function create($type) {

    if ($type == 1) {
        return "A";
    } elseif ($type == 2) {
        return "B";
    } elseif ($type == 3) {
        return "C";
    }
}

this code is good and worked but not clean code.

clean code

we can convert this code to be like:

priviate $array = [1 => 'A', 2 => 'B', 3 => 'C']; 

public function create($type) {


    return key_exists($type, $this->array)? $this->array[$type]:false; 
}

How To Delete a GitHub Repository

Moataz khaled — Thu, 08 Apr 2021 09:40:10 +0000

Delete GitHub repository

In order to delete a GitHub repository, you have to follow the steps described below :

1- Click on your profile picture at the top right corner
of the GitHub interface and click on
“Your repositories“.

2- On your repository list, select the GitHub repository
that you want to delete.

3- On the repository page, click on “Settings” in the
menu.

4- In the repository settings, scroll down until you see
the “Danger zone“.

5- In the “danger zone”, click on “Delete this repository“
To confirm the GitHub repository deletion, you have to

type the repository name. When you are done, simply
click on
“I understand the consequences, delete this repository“.

6- Congratulations, you have successfully deleted your
GitHub repository!

the Best way to use Laravel with Nosql Mongodb

Moataz khaled — Wed, 07 Apr 2021 15:13:19 +0000

1 -The first step we need to sure we installed Mongodb in the global environment on the PC.

2 - Installation

if ready I will be run in my project this command

 "$ composer require jenssegers/mongodb"

3-Laravel

In case your Laravel version does NOT autoload the packages, add the service provider to config/app.php:

Jenssegers\Mongodb\MongodbServiceProvider::class,

4- Configuration

You can use MongoDB either as the main database, either as a side database. To do so, add a new MongoDB connection to config/database.php:

     'mongodb' => [
        'driver' => 'mongodb',
        'host' => env('MONGO_DB_HOST','localhost'),
        'port' => env('MONGO_DB_PORT'),
        'database' => env('MONGO_DB_DATABASE'),
        'username' => env('MONGO_DB_USERNAME'),
        'password' => env('MONGO_DB_PASSWORD'),
        'options' => []
     ],

if need to used DSN :

    'mongodb' => [
        'driver' => 'mongodb',
        'dsn' => env('MONGO_DB_DSN'),
        'database' => env('MONGO_DB_DATABASE'),
    ]

5 - env File '.env'

     MONGO_DB_HOST=127.0.0.1
     MONGO_DB_PORT=27017
     MONGO_DB_DATABASE={my_db}
     MONGO_DB_USERNAME={my_user}
     MONGO_DB_PASSWORD={my_password}

if need to used DSN :

    MONGO_DB_DSN= {my_link_dsn}