DEV Community: Mahfuzur Rahman

Exploring MySQL Full-Text Search and Its Implementation in Laravel

Mahfuzur Rahman — Sun, 02 Feb 2025 06:12:43 +0000

Imagine you’re building a news website or a blog, and you need a fast and efficient way to search through thousands (or even millions) of articles. Traditional LIKE queries in MySQL won’t cut it they’re slow and inefficient. This is where MySQL Full-Text Search (FTS) comes into play! 🚀

Full-Text Search is MySQL’s built-in solution for powerful, efficient text searching. In this article, we’ll break down what it is, how it works, and how you can implement it in Laravel.

What is MySQL Full-Text Search?

Full-Text Search (FTS) is a feature in MySQL that allows you to perform advanced text-based queries using indexes rather than scanning entire tables. This makes searches much faster compared to the traditional LIKE operator.

How It Works 🔍

Indexing: MySQL creates a FULLTEXT index on specific columns.
Tokenization: Text is broken into words (tokens) and stored in an index.
Ranking: When a search query is executed, MySQL retrieves results based on relevance scoring.

Full-Text Search Modes

MySQL provides two main modes:

Natural Language Mode (Default) Returns results ranked by relevance.
Boolean Mode — Allows custom search logic using operators like +, -, OR, NOT.

Setting Up Full-Text Search in Laravel

1. Creating the Database Table
First, create a migration to add a FULLTEXT index to your table:

Schema::create('news', function (Blueprint $table) {
    $table->id();
    $table->string('title');
    $table->text('content');
    $table->timestamps();

    $table->fullText(['title', 'content']); // Adding FULLTEXT index
});

2. Performing a Full-Text Search
You can now use MySQL’s MATCH() function in Laravel queries:

$search = 'election results';

$results = DB::table('news')
    ->whereRaw("MATCH(title, content) AGAINST(? IN NATURAL LANGUAGE MODE)", [$search])
    ->get();

This query will return articles ranked by relevance.

3. Using Boolean Mode for Advanced Searches

Need more control? Use Boolean Mode:

$search = '+election -fake';

$results = DB::table('news')
    ->whereRaw("MATCH(title, content) AGAINST(? IN BOOLEAN MODE)", [$search])
    ->get();

This ensures results must contain “election” but must not contain “fake.”

4. Full-Text Search in Eloquent
Want a cleaner approach? Use Eloquent:

class News extends Model
{
    public function scopeSearch($query, $keywords)
    {
        return $query->whereRaw("MATCH(title, content) AGAINST(? IN NATURAL LANGUAGE MODE)", [$keywords]);
    }
}

$articles = News::search('technology trends')->get();

This makes it reusable across your application.

Optimizing Full-Text Search Performance

Use Short Columns: Store only necessary text in the FULLTEXT index.
Limit Results: Always paginate or limit query results.
Consider External Search Engines: If your dataset is huge, try Meilisearch or Elasticsearch.
MySQL Full-Text Search is a powerful tool for fast and efficient text searching. When combined with Laravel, it provides an easy and flexible way to implement advanced search features.

So, whether you’re building a news portal, a blog, or an e-commerce site, leveraging Full-Text Search can significantly enhance the user experience.

And with Redis Caching, it will be a lot faster. Happy Coding!!!!

Docker Multi-Container Deployment with GitHub Actions in Laravel

Mahfuzur Rahman — Mon, 20 Jan 2025 07:03:55 +0000

In today’s tech world, applications often rely on multiple interconnected services (containers) to function seamlessly — think of a web app working alongside a database, a cache, and a load balancer. Deploying such a multi-container application can seem daunting, but with GitHub Actions, you can set up a smooth CI/CD pipeline to deploy your app to production. Here’s a casual walk-through of how it’s done.

What’s Multi-Container Deployment?

It’s the process of deploying multiple Docker containers that work together as a system. For instance, a Laravel app might use:

A container for the application code.
Another is for the MySQL database.
Nginx is used to serve static files and proxying requests.

Step 1: Prerequisites

Before jumping into deployment:

Dockerize Your Application: Ensure each service has a Dockerfile.
Set Up Docker Compose: A docker-compose.yml file to orchestrate the containers.
Provision a Server: A VPS (like DigitalOcean or AWS Lightsail) with Docker and Docker Compose installed.

Step 2: Build Your GitHub Actions Workflow

GitHub Actions lets you automate testing, building, and deploying. Here’s a simple workflow for deploying a Dockerized app:

name: Multi-Container Deployment
on:
  push:
    branches: [main]
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      # Checkout code
      - name: Checkout Repository
        uses: actions/checkout@v2
      # Build Docker Images
      - name: Build Docker Images
        run: |
          docker-compose -f docker-compose.yml build
      # Push Images to Docker Hub
      - name: Push Images
        env:
          DOCKER_USERNAME: ${{ secrets.DOCKER_HUB_USERNAME }}
          DOCKER_PASSWORD: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
        run: |
          echo "$DOCKER_PASSWORD" | docker login -u "$DOCKER_USERNAME" --password-stdin
          docker-compose -f docker-compose.yml push
      # Deploy to VPS
      - name: Deploy to VPS
        uses: appleboy/ssh-action@v0.1.4
        with:
          host: ${{ secrets.VPS_SERVER_IP }}
          username: ${{ secrets.VPS_USERNAME }}
          key: ${{ secrets.SSH_PRIVATE_KEY }}
          script: |
            cd /path/to/your/app
            docker-compose pull
            docker-compose down
            docker-compose up -d

How It Works

Trigger on Push: The workflow starts whenever you push to the main branch.
Build Docker Images: Images for each container are built using docker-compose.yml.
Push to Docker Hub: Built images are uploaded to Docker Hub (or another container registry).
Deploy to VPS: The workflow logs into your server via SSH, pulls the latest images, and restarts the containers using docker-compose.

Why This Workflow Rocks

Automation: No manual SSH-ing or running commands — it’s all automated.
Consistency: Every deployment uses the same images built in CI, ensuring consistency.
Simplicity: Docker Compose simplifies managing multi-container apps.

And that’s it! With this workflow, you can confidently deploy your multi-container app without breaking a sweat. Happy deploying!

What Happens When You Run “php artisan serve” in Laravel?

Mahfuzur Rahman — Mon, 02 Dec 2024 18:58:25 +0000

Laravel is one of the most popular PHP frameworks, making web development efficient and enjoyable. As a developer, you’ve likely used the php artisan serve command to quickly start a local development server. But have you ever wondered what happens behind the scenes when you run this command? Let’s explore this in detail, step by step, understand how Laravel identifies and runs the ServeCommand, and dive into what PHP’s built-in server is and how it compares to traditional web servers like Nginx or Apache.

What is php artisan serve?

The php artisan serve command is a Laravel feature that starts a local web server for your project. It uses PHP’s built-in server to make your Laravel application accessible at a specific address (e.g., http://127.0.0.1:8000) during development.

This command is especially useful for local development because it doesn’t require setting up a full-fledged web server like Nginx or Apache.

Step-by-Step Process: What Happens When You Run php artisan serve?

1. User Runs the Command
When you type php artisan serve in the terminal, Laravel's Artisan Console a command line tool for Laravel, kicks into action. It’s like a toolbox with various commands to assist in building, testing, and running Laravel applications.

2. Artisan Entry Point

The artisan file in your project’s root directory acts as the entry point for all Artisan commands.
When you run php artisan serve, the artisan file does the following:

Includes Composer’s autoloader (vendor/autoload.php).
Bootstraps the Laravel framework using bootstrap/app.php.

3. Artisan Finds the ServeCommand

Laravel registers all Artisan commands when the application boots. For built-in commands like serve, Laravel registers them in the Illuminate\Foundation\Providers\ArtisanServiceProvider.
This provider maps the command name (serve) to its corresponding class (Illuminate\Foundation\Console\ServeCommand).

4. Command Resolution and Autoloading

The ServeCommand is located in the vendor/laravel/framework directory under the namespace Illuminate\Foundation\Console.
Laravel uses Composer’s PSR-4 autoloading configuration to locate and load the class.
This allows the ServeCommand class to be loaded without the full Laravel framework being fully initialized yet.

5. Preparing the Server

The ServeCommand configures the PHP built-in server:
Host: Default is 127.0.0.1 (localhost).
Port: Default is 8000 (or a custom one via --port option).
Document Root: Points to the public directory where Laravel’s entry file (index.php) resides.
Internally, the command executes:

php -S 127.0.0.1:8000 -t public server.php

php -S Starts PHP’s built-in server.
-t public Specifies the document root.
server.php: A router file to handle dynamic requests.

6. Handling Requests

The server.php file acts as a router:
If the requested file (e.g., CSS, JS) exists, it is served directly.
Otherwise, requests are forwarded to index.php.

7. Laravel Processes the Request

The index.php file initializes Laravel’s framework and handles incoming HTTP requests.
It routes the request to the appropriate controller, processes the logic, and generates a response (e.g., HTML or JSON).

8. Response is Sent Back

The Laravel response is sent back to the PHP built-in server, which then delivers it to the browser.

What is PHP’s Built-In Server?

PHP’s built-in server is a simple development server introduced in PHP 5.4. It’s designed to help developers test applications without needing to install or configure a full web server.

Features of PHP Built-In Server:

Ease of Use: Start it with a single command (php -S).
Dynamic and Static Files: Serves both PHP scripts and static files like images or stylesheets.
Custom Routing: Allows custom handling of requests through a router script (like Laravel’s server.php).

Comparison: PHP Built-In Server vs. Nginx/Apache

Purpose: The PHP Built-in Server is For Development purposes only. Nginx/Apache is for both Production-ready and development.
Performance: The PHP built-in server is Single-threaded (one request at a time) and Nginx/Apache is Multi-threaded (handles many requests concurrently)
Configuration: The PHP built-in server minimal setup requires. nginx/Apache needs configuration files.
Advanced Features: The PHP built-in server is Limited (e.g., no caching). Nignx/Apache can be used for Caching, load balancing, and more.

While this setup is convenient, it’s meant only for development. For live applications, web servers like Nginx or Apache provide the scalability and performance necessary for handling production traffic.

P.S. It always interests me to learn how things work behind the scenes. This helps me understand what is actually happening when I am building an application. You can read my other articles.

What is PHP Fiber? Does PHP Fiber Really Give You Asynchronous Execution?

Mahfuzur Rahman — Fri, 29 Nov 2024 19:04:58 +0000

When PHP 8.1 introduced Fibers, many developers wondered if they were a solution to PHP’s long-standing limitation as a single-threaded, synchronous language. Could Fibers make PHP asynchronous, like JavaScript with its event loops or Node.js? The answer is subtle: Fibers don’t provide true asynchronous execution, but they are a powerful tool for managing tasks more efficiently. Let’s explore this concept in detail.

What Are PHP Fibers?

Fibers are a mechanism for implementing cooperative multitasking in PHP. They allow you to pause and resume specific parts of code without blocking the entire PHP process. Think of a Fiber as a specialized function that can “yield” control back to the main program and then continue execution from where it left off when requested.

Key Features of Fibers:

You can start, pause, and resume their execution.
They operate within the same PHP process and do not introduce multi-threading.
They are particularly useful for structuring non-blocking code.

What Happens When a Fiber Is Paused?

When a Fiber is paused using Fiber::suspend(), the control returns to the main PHP script. This means:

The main process is free to continue executing other parts of your program.
The Fiber’s execution is halted temporarily, waiting for a resume() call.

For example:

$fiber = new Fiber(function () {
    echo "Fiber started\n";
    Fiber::suspend();
    echo "Fiber resumed\n";
});

echo "Before Fiber\n";
$fiber->start();
echo "After Fiber Start\n";
$fiber->resume();
echo "After Fiber Resume\n";
Output:

Before Fiber
Fiber started
After Fiber Start
Fiber resumed
After Fiber Resume

Here’s what’s happening:

Fiber::suspend() pauses the Fiber. Execution shifts back to the main script after $fiber->start().
The main script continues running (“After Fiber Start”).
When resume() is called, the Fiber picks up where it left off and completes its task.

Does Resuming a Fiber Block the Main Process?

Yes, but only temporarily. When you call Fiber::resume(), the Fiber runs synchronously within the main PHP process. During this time:

Other parts of your script (or other Fibers) cannot execute until the Fiber completes or pauses again.
The execution of the Fiber is blocking because PHP remains single-threaded. For example:

$fiber = new Fiber(function () {
    echo "Processing Fiber...\n";
    sleep(2); // Simulates a blocking task
    echo "Fiber Done\n";
});

echo "Before Fiber\n";
$fiber->start();
echo "Between Fiber Start and Resume\n";
$fiber->resume();
echo "After Fiber\n";
Output:

Before Fiber
Processing Fiber...
Fiber Done
Between Fiber Start and Resume
After Fiber

Here, the Fiber blocks the main process during the sleep(2) call. So, while Fibers provide a way to structure code for efficiency, they don’t magically enable parallel or truly asynchronous execution.

How Are Fibers Still “Non-Blocking”?

The term “non-blocking” refers to how Fibers enable better task management, not parallel execution. A Fiber doesn’t block the main process while it’s paused; instead, control is handed back to the main script or an event loop.

This is particularly useful for libraries or frameworks that use event-driven architectures, like ReactPHP or Amp, where:

Long-running or waiting tasks (e.g., database queries, API calls) can be suspended.
Other tasks can continue running in the meantime.
Once the task is ready, the Fiber is resumed, and its execution continues.

Imagine you are a chef preparing multiple dishes:
You start cooking a dish but pause to wait for something to boil.
While waiting, you begin preparing another dish.
When the first dish is ready, you return to it and continue cooking.

Similarly, Fibers allows PHP to “pause” a task and return to it later without holding up the entire process.

Why Fibers Are Not Truly Asynchronous.

Unlike asynchronous programming in JavaScript or Node.js, where tasks can run in parallel using threads or an event loop, Fibers:

Execute synchronously within a single PHP process.
Provide cooperative multitasking by allowing the developer to manually control task suspension and resumption.

In other words:
Fibers don’t introduce parallelism (tasks still run one at a time).
They are a tool for managing and structuring non-blocking code more efficiently.
While PHP Fibers don’t make PHP truly asynchronous, they are a powerful addition to the language.

PHP is a Single-Threaded Language, So How Does Laravel Handle Queue Jobs Asynchronously?

Mahfuzur Rahman — Thu, 28 Nov 2024 12:47:45 +0000

PHP is known as a single-threaded language, meaning it can only execute one task at a time within a single process. However, Laravel provides a robust queue system to handle multiple tasks “asynchronously.” If PHP is single-threaded, how does Laravel achieve this magic? Let’s break it down in simple terms.

What is a PHP Process?

Before diving into queues, we need to understand what a PHP process is.

A process is like a worker hired to complete a task. When you execute a PHP script (e.g., php my_script.php), the operating system creates a new process. This process:

Loads the PHP script.
Executes the code step-by-step.
Stops and “dies” when the task is done. For example:

echo "Hello World!";

When you run this script, PHP starts a process, displays “Hello World!”, and then the process ends.

PHP in Web Applications

In web applications:

A web server (like Apache or Nginx) receives an HTTP request from a browser.
The server creates a new PHP process to handle the request.
PHP processes the request (e.g., fetching data from a database or rendering a page).
The process ends after sending a response to the browser.
PHP processes are short-lived. They handle one request at a time and then stop. This design makes PHP simple and efficient for web applications.

What is Single-Threaded?

PHP is single-threaded, meaning:

A PHP process can only handle one task at a time.
It doesn’t perform multiple tasks simultaneously in the same process. For example:

echo "Task 1";
// Waits for Task 1 to finish before starting Task 2
echo "Task 2";

PHP executes Task 1 first. Only after it’s done does it move to Task 2. This behavior is different from languages like JavaScript, where tasks can run in parallel in the same process.

How Does Laravel Handle Queues Then?

Laravel’s queue system allows you to run multiple tasks in the background without blocking the main application. For example:

Sending emails.
Processing image uploads.
Sending notifications. These tasks run in the background, so your main application can respond to users faster.

But PHP can only handle one task at a time, right? How does Laravel make it seem asynchronous? The answer lies in workers and multiple processes.

What is a Worker?

A worker in Laravel is a long-running PHP process that listens for jobs in a queue and executes them.

When you run the command:

php artisan queue:work

A new PHP process (or worker) starts. This process:

Connects to the queue system (like Redis or a database).
Waits for new jobs (tasks) to arrive in the queue.
Picks up and processes jobs one by one. Example: Imagine you have a task to send 1,000 emails: The main application sends 1,000 jobs to the queue. A worker process picks up one job, sends the email, and moves to the next job.

How Does Laravel Achieve Asynchronous Behavior?

Laravel achieves “asynchronous” behavior by running multiple workers at the same time. Each worker is a separate PHP process.

Here’s how it works:
When you run php artisan queue:work, it starts with one worker (one PHP process).
You can start multiple workers to process jobs in parallel on different tabs locally and in production using the process manager like the supervisor.
This will start multiple PHP processes. Each worker handles jobs independently, making it seem like tasks are running simultaneously.

What Happens When a Job is Queued?

When you queue a job in Laravel, here’s what happens step-by-step:

Job Creation: The job (e.g., send an email) is serialized (converted into a storable format) and added to the queue backend (like Redis or a database).
Worker Polls the Queue: Workers continuously check the queue for new jobs. If a job is found, the worker picks it up.
Job Execution: The worker deserializes the job and runs its handle() method. Once done, the job is marked as completed.
Job Completion: The worker removes the job from the queue.

If the job fails, Laravel retries it or moves it to a “failed jobs” list (based on your configuration).

Example Scenario: Sending Emails
Imagine you have a Laravel application where users submit a contact form. When the form is submitted:

The main application processes the form and responds to the user immediately.
Instead of sending the email right away, it adds the email-sending task to a queue.

In the background:

A worker picks up the email-sending job.
Sends the email.
Moves to the next job.
This way, the user doesn’t have to wait for the email to be sent, making the app faster.

How Do Workers Run in Production?

In production, Laravel workers are managed by tools like Supervisor. The supervisor keeps workers running 24/7 and restarts them if they crash.

Supervisor Configuration Example:

[program:laravel-worker]
command=php /path/to/artisan queue:work --tries=3
numprocs=5

command: Runs the queue:work command.
numprocs=5: Starts 5 workers (5 PHP processes) to handle jobs.

Is It Truly Asynchronous?

Technically, Laravel queues are not asynchronous in the way JavaScript or Node.js handle tasks. Instead:

Each worker handles one job at a time.
Multiple workers (processes) provide parallelism, giving the appearance of asynchronous execution.

Key Points to Remember

PHP is single-threaded, so a single PHP process handles one task at a time.
Laravel uses workers (long-running PHP processes) to process queue jobs.
Multiple workers can run simultaneously, allowing jobs to be processed in parallel.
Queue backends (like Redis) act as middlemen to store jobs until workers pick them up.
Tools like Supervisor ensure workers run continuously in production.

Laravel’s queue system is a smart way to handle tasks in the background, improving application performance and user experience. While PHP itself is single-threaded, Laravel achieves parallelism by running multiple processes (workers). This simple yet effective design allows Laravel to handle heavy workloads, even with PHP’s limitations.

Best Redis Caching Strategy in Laravel: A Guide to Fast and Efficient Caching

Mahfuzur Rahman — Mon, 11 Nov 2024 07:40:44 +0000

Laravel and Redis are a powerful combination for boosting application speed and performance. Redis, an in-memory key-value store, is perfect for caching, especially when you need fast and frequent data access. In this guide, we'll look at effective caching strategies in Laravel with Redis. We'll cover how to cache data, manage expiration times, and efficiently clear caches.

Why Use Redis Caching?
When you cache with Redis in Laravel, you're essentially saving data temporarily to reduce the time spent querying the database. Caching speeds up data retrieval, reduces server load, and improves user experience by making pages load faster.

Redis is ideal for caching because it:

Can quickly store and retrieve data
Supports various data structures like strings, lists, and hashes
Offers tools for managing cache expiration and clearing old data

Let's explore how to best use Redis caching in Laravel.
Let's say we have a News Paper Site. Now we need to build Api to Get News.

1. Setting Up Basic Caching with Laravel and Redis

To start, let's cache a simple API response, like a list of the latest news articles.

$data = Cache::remember('latest_news', 3600, function () {
    return News::latest()->get();
});

In this example:
Cache::remember stores data with a key (latest_news) and a time-to-live (TTL) of 3600 seconds (1 hour).
If a request for latest_news comes in again within the hour, Redis serves the cached data without querying the database.

2. Structuring Cache Keys and Expiration Times

To keep the data fresh without overloading Redis:
Set shorter TTLs for frequently updated data (e.g., 15–30 minutes).
Use longer TTLs (e.g., 1–2 hours) for data that rarely changes.

Use specific, structured cache keys that reflect the data content. For example:

$cacheKey = "news:category:category_1";

This key is clear, unique, and self-descriptive, making it easy to identify and manage within Redis.

3. Using Tags for Grouped Cache Management

Redis supports tags, which let us manage grouped data under a common tag. For example, tagging all news-related caches with news:

Cache::tags(['news', 'category'])->remember('category_news_1', 3600, function () {
    return $this->news_repository->getNewsByCategory(1);
});

Now, if we want to clear all category-specific news caches (when news is updated), we can use:

Cache::tags(['news', 'category'])->flush();

Caching Paginated and Filtered Data When adding pagination or filters (like category or tags), make each cache key unique to the parameters:

$page = request()->input('page', 1);
$limit = request()->input('limit', 10);
$cacheKey = "news:page_{$page}:limit_{$limit}";

$newsData = Cache::remember($cacheKey, 3600, function () use ($page, $limit) {
    return News::latest()->paginate($limit, ['*'], 'page', $page);
});

This way:
A unique cache entry is created for each page and limit.
Users can fetch pages quickly without re-querying the database.

For filtered data, include the filter parameters in the key:

$categoryId = request()->input('category_id');
$cacheKey = "news:category_{$categoryId}:page_{$page}:limit_{$limit}";

This ensures each category and page combination has its own cache entry.

5. Automatic Cache Invalidation on Data Changes

Clearing or "invalidating" caches ensures users see updated data when necessary. Here's how to automate it:
Use model observers for events like created, updated, or deleted to clear related caches.
Example observer for news:

public function created(News $news) {
    Cache::tags(['news', 'pagination'])->flush();
}

public function updated(News $news) {
    Cache::tags(['news', 'pagination'])->flush();
}

Now, whenever news is added or updated, all news and pagination tagged caches are flushed, keeping the data fresh.

6. Summary and Best Practices

To make caching work effectively:
Unique Keys: Structure keys with parameters like category, page, and limit.
Tags for Grouped Data: Use tags to easily manage caches for specific data groups.
Automate Invalidation: Set up observers to clear outdated caches on data changes.
Set Sensible Expiration: Choose TTLs based on how often the data changes, typically between 15 minutes and 1 hour.

Using Redis with this structured approach makes Laravel APIs respond faster, improves server load management, and ensures a reliable, efficient cache strategy that's easy to manage.

Where Does Deleted Data Go? Unveiling the Secrets of File Deletion and Overwriting

Mahfuzur Rahman — Wed, 02 Oct 2024 14:51:41 +0000

Ever wondered where the files go when you delete them from your computer or phone? Are they really gone or are they just playing an epic game of hide and seek behind those memory blocks, waiting to be recovered? I’ve got a burning curiosity and an urge to understand what actually happens at the lowest level when we delete a file. So, let’s embark on this journey of discovery… and hopefully, we’ll find out that the files aren’t just off on a tropical vacation!

To understand what happens when a file is deleted and overwritten, and how the storage system handles data at a deeper level, we need to break down how files are stored and managed on a storage device. We’ll also dive into the physical aspects of how bits and bytes are written, erased, and overwritten, and explain why they don’t “pile up” or continue to occupy space after being overwritten.

When you delete a file from your hard drive or SSD, the data isn't immediately erased. Instead, the system removes the file's reference and marks the storage space as available for reuse. On traditional hard drives (HDDs), the data remains as magnetic patterns until it's overwritten by new data. In solid-state drives (SSDs), a TRIM command marks the data for erasure, allowing faster overwriting. While deleted data can sometimes be recovered before it's overwritten, once new data replaces it, the old information is effectively lost. For secure deletion, special tools overwrite the data multiple times to ensure it cannot be restored. Understanding this process is crucial for managing storage and protecting sensitive information.

You can read my details explanation from here - My Blog

Laravel `loadCount` Relationship Count 😎

Mahfuzur Rahman — Tue, 26 Dec 2023 03:40:26 +0000

Hello Artisans 😎

Did you know you can get relationship counts even after retrieving the parent model? 🤔

Using the loadCount method, you may load a relationship count after the parent model has already been retrieved:

$book = Book::first();

$book->loadCount('genres');

If you need to set additional query constraints on the count query, you may pass an array keyed by the relationships you wish to count. The array values should be closures which receive the query builder instance:

$book->loadCount(['reviews' => function (Builder $query) {
    $query->where('rating', 5);
}])

How to use PHP within JavaScript on the Laravel framework.

Mahfuzur Rahman — Tue, 14 Nov 2023 08:57:51 +0000

Hey Laravel Devs 📢
Do you know? You can use Laravel Blades

{{ }}

in JS and use PHP variables in there.

Also, You Can Use Route In Ajax URL

But your JS must be in the Blade file inside the "script" tag.

Laravel #javascript

Dynamic Components In Vue

Mahfuzur Rahman — Thu, 09 Nov 2023 04:35:52 +0000

Dynamic components allow you to switch between different components based on a condition without using multiple conditional statements. To create a dynamic component, use the reserved tag with the 'is' attribute.

<component v-bind:is="currentComponent"></component>

In your Vue.js instance, you can update the value of 'currentComponent' to switch between components.

new Vue({
  el: '#app',
  data: {
    currentComponent: 'component-a'
  },
  components: {
    'component-a': ComponentA,
    'component-b': ComponentB
  }
});

Optimizing Vue Js Performance: Practical Tips and Code Examples Part 1

Mahfuzur Rahman — Wed, 08 Nov 2023 08:51:27 +0000

Performance optimization is crucial when developing Vue.js applications, especially as they grow in complexity. In this article, we will explore practical tips and code examples to help you squeeze the best performance out of your Vue.js projects.

Use v-for with a Unique Key.

When rendering lists with v-for, ensure each item has a unique key. This allows Vue to efficiently track and update elements in the list, improving rendering performance.

Computed Properties

Use computed properties to cache and efficiently manage complex calculations or data transformations. This reduces redundant calculations and improves rendering performance.

Keep Watchers and Listeners Minimal

Avoid creating unnecessary watchers and event listeners, as they can lead to performance bottlenecks. Only watch or listen to changes that are critical for your component’s functionality.

I write on Medium Regularly. You can follow me for regular tips. https://medium.com/@mahfuz34

Javascript Underrated Method "endsWith()"

Mahfuzur Rahman — Mon, 06 Nov 2023 08:53:52 +0000

The endsWith function is a method available in JavaScript for strings. It is used to check if a string ends with a specified substring, and it returns a Boolean value (true or false) based on the result of the check.

Here's the basic syntax of the endsWith function:

string.endsWith("searchString", length]);

string: The original string you want to check.
searchString: The substring you want to check for at the end of the original string.
length (optional): The length of the string to consider. If provided, endsWith will check if the substring appears within the first length characters of the original string.

The function returns true if the original string ends with the specified substring, and false otherwise.

Here are some examples:

const str = "Hello, world!";

console.log(str.endsWith("world"));  // true
console.log(str.endsWith("!"));      // true
console.log(str.endsWith("Hello"));   // false
console.log(str.endsWith("world", 7); // true (only considering the first 7 characters)

In the first example, the string "Hello, world!" ends with "world," so endsWith returns true.
In the second example, it ends with "!" and returns true again.
In the third example, it does not end with "Hello," so it returns false.
The fourth example demonstrates the use of the optional length parameter, where we check if "world" appears within the first 7 characters of the string, which returns true.