DEV Community: Code Of Accuracy

async & await

Code Of Accuracy — Thu, 20 Apr 2023 09:09:26 +0000

Asynchronous programming in JavaScript can be a bit challenging, especially when dealing with code that depends on network requests or other long-running tasks. However, the introduction of the async and await keywords in ES2017 (also known as ES8) has greatly simplified asynchronous programming in JavaScript. In this article, we'll explore what async and await are, and how to use them.

What are async and await?
async and await are two new keywords introduced in ES2017 that simplify asynchronous programming in JavaScript. The

async keyword is used to define an asynchronous function, which returns a promise that is resolved with the function's return value.
await keyword is used to pause the execution of an async function until a promise is resolved.

An async function is defined like this:

async function myAsyncFunction() {
  // Code here
}

Inside an async function, you can use the await keyword to pause the function execution until a promise is resolved. The syntax for using await looks like this:

let result = await myPromise;

myPromise is a promise that you want to wait for, and result is the value that the promise resolves to.

Fetching data from an API

Let's take a look at an example that demonstrates how to use async and await to fetch data from an API.

Suppose we have an API endpoint that returns a list of users. The endpoint is available at https://jsonplaceholder.typicode.com/users. We want to fetch this data and log the names of the users to the console.

Here's how we can do it using async and await:

async function getUsers() {
  try {
    const response = await fetch('https://jsonplaceholder.typicode.com/users');
    const data = await response.json();
    const names = data.map(user => user.name);
    console.log(names);
  } catch (error) {
    console.error(error);
  }
}

getUsers();

Here, we define an async function called getUsers that fetches the data from the API using the fetch function. We then use the await keyword to pause the function execution until the data is fetched and parsed as JSON using the json method of the response object.

Once we have the data as an array of user objects, we use the map method to extract the name property of each user, and then log the resulting array of names to the console.

In case there's an error during the fetch or parsing process, we handle it using a try-catch block.

Finally, we call the getUsers function to start the asynchronous operation.

*Repl as Example : *

Promises in Javascript

Code Of Accuracy — Mon, 17 Apr 2023 06:39:17 +0000

In JavaScript, a Promise is a built-in object that represents the eventual completion (or failure) of an asynchronous operation, and its resulting value. It provides a cleaner and more organized way to handle asynchronous code, avoiding the infamous callback hell.

Here's an example of how to use Promises in JavaScript:

const getData = () => {
  return new Promise((resolve, reject) => {
    // Perform an asynchronous operation, such as fetching data from an API Currently we are taking static data for example.
    const data = { id: 1, name: "Sam Adam" };
    if (data) {
      // If the operation is successful, call the "resolve" method with the data
      resolve(data);
    } else {
      // If there's an error, call the "reject" method with the error message
      reject("Error: Unable to retrieve data.");
    }
  });
};

// Call the Promise function and handle the response using "then" and "catch" methods
getData()
  .then((data) => {
    console.log("Data retrieved successfully:", data);
  })
  .catch((error) => {
    console.error("Error occurred while retrieving data:", error);
  });

In the example above, the getData() function returns a Promise object, which performs an asynchronous operation of fetching data from an API. If the operation is successful, the Promise calls the resolve() method with the data, and if there's an error, it calls the reject() method with the error message.

To handle the response from the Promise, you can use the then() and catch() methods. The then() method is called when the Promise is resolved successfully, and it receives the data as a parameter. The catch() method is called when the Promise is rejected with an error, and it receives the error message as a parameter.

Chaining Promises

const getData = () => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const data = { id: 1, name: "John Doe" };
      if (data) {
        resolve(data);
      } else {
        reject(new Error("Unable to retrieve data."));
      }
    }, 2000);
  });
};

const getDetails = (data) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const details = { age: 30, city: "New York" };
      if (details) {
        resolve({ ...data, ...details });
      } else {
        reject(new Error("Unable to retrieve details."));
      }
    }, 2000);
  });
};

getData()
  .then(getDetails)
  .then((result) => {
    console.log(result); // Output: { id: 1, name: "John Doe", age: 30, city: "New York" }
  })
  .catch((error) => {
    console.error(error);
  });

In the example above, we have two Promises, getData() and getDetails(), that simulate fetching data from an API. The getDetails() Promise depends on the data returned by the getData() Promise. We use the then() method to chain these Promises together. The then() method takes a callback function that returns another Promise. The value returned by the first Promise is passed as an argument to the callback function of the second Promise. This process can be repeated as many times as necessary.

We use the getData() Promise to retrieve some data, and then chain the getDetails() Promise to retrieve additional details about that data. Finally, we use the then() method to log the result of both Promises chained together.

Promise.all()

The Promise.all() method allows you to run multiple Promises in parallel and wait for all of them to complete. This method takes an array of Promises as its argument and returns a new Promise that is fulfilled when all of the Promises in the array have been fulfilled.

const promise1 = new Promise((resolve) => setTimeout(resolve, 2000, "foo"));
const promise2 = 10;
const promise3 = new Promise((resolve) =>
  setTimeout(resolve, 3000, "bar")
);

Promise.all([promise1, promise2, promise3]).then((values) =>
  console.log(values)
);
// Output: ["foo", 10, "bar"]

In the example above, we create three Promises and pass them to the Promise.all() method. The then() method is used to log the array of values returned by the Promises when they are all fulfilled.

Promise.race()

The Promise.race() method allows you to run multiple Promises in parallel and return the value of the first Promise that is fulfilled.

const promise1 = new Promise((resolve) => setTimeout(resolve, 2000, "foo"));
const promise2 = new Promise((resolve) =>
  setTimeout(resolve, 3000, "bar")
);

Promise.race([promise1, promise2]).then((value) => console.log(value));
// Output: "foo"

In the example above, we create two Promises and pass them to the Promise.race() method. The then() method is used to log the value of the first Promise that is fulfilled. In this case, promise1 is fulfilled first, so its value ("foo") is logged.

Promise.allSettled()

Promise.allSettled() was introduced in ES2020. It takes an array of Promises as its input and returns a new Promise that resolves to an array of objects, one for each Promise in the input array. Each object in the resulting array represents the state of the corresponding Promise and contains two properties:

status: The status of the Promise. It can be either "fulfilled" or "rejected".

value or reason: Depending on whether the Promise was fulfilled or rejected, this property contains either the fulfilled value or the rejection reason.

Here's an example of how Promise.allSettled() works:

const promises = [
  Promise.resolve("resolved"),
  Promise.reject("rejected"),
  Promise.resolve("resolved again"),
];

Promise.allSettled(promises).then((results) => console.log(results));
// Output: [
//   { status: "fulfilled", value: "resolved" },
//   { status: "rejected", reason: "rejected" },
//   { status: "fulfilled", value: "resolved again" }
// ]

In this example, we create an array of three Promises. The first and third Promises are fulfilled with the values "resolved" and "resolved again", respectively. The second Promise is rejected with the reason "rejected". We then pass this array of Promises to Promise.allSettled(), which returns a new Promise that resolves to an array of three objects representing the state of each Promise. The then() method is used to log the resulting array of objects to the console.

Note that unlike Promise.all(), Promise.allSettled() waits for all Promises to settle (i.e., either fulfill or reject), regardless of their outcome. This means that even if some of the Promises are rejected, the resulting Promise returned by Promise.allSettled() will still resolve with an array of objects representing the state of all the Promises.

Repl as Example : https://replit.com/@CodeOf1/PromisesAPI

Summary
Promises are a powerful tool in JavaScript for working with asynchronous code. They allow you to handle the success and failure of asynchronous operations in a more structured and readable way. In addition to the then() and catch() methods, you can also chain Promises together with the then() method, and run multiple Promises in parallel with the Promise.all() and Promise.race() methods.

Collection In Laravel

Code Of Accuracy — Mon, 10 Apr 2023 10:53:36 +0000

A collection is a robust data structure that allows developers to work with arrays of data more easily and efficiently. It provides an object-oriented approach to working with arrays and offers a wide range of methods that can be used to manipulate, filter, sort, and transform data.

Here's an example of how to create a collection in Laravel:

$collection = collect(['apple', 'orange', 'banana', 'kiwi']);

In this example, we have created a collection of fruits. Now we can use various methods to work with this collection. For example, we can use the filter method to filter out all the fruits that start with the letter a:

$filtered = $collection->filter(function ($value, $key) {
    return Str::startsWith($value, 'a');
});

// Output: ['apple']

In this example, we have used the filter method to create a new collection that only contains the fruit apple, which is the only fruit that starts with the letter a.

We can also use the sort method to sort the fruits alphabetically:

$sorted = $collection->sort();

// Output: ['apple', 'banana', 'kiwi', 'orange']

In this example, we have used the sort method to create a new collection that contains the fruits sorted alphabetically.

One of the main benefits of collections in Laravel is the ability to chain methods together, allowing developers to perform multiple operations on a collection in a single line of code. Here's an example of how we can create a collection of users and filter them by age and then sort them by name:

$users = collect([
    ['name' => 'John', 'age' => 30],
    ['name' => 'Jane', 'age' => 25],
    ['name' => 'Bob', 'age' => 35],
    ['name' => 'Sarah', 'age' => 28]
]);

$filteredUsers = $users
    ->where('age', '>', 25)
    ->sortBy('name');

// Output: [['name' => 'Jane', 'age' => 25], ['name' => 'John', 'age' => 30], ['name' => 'Sarah', 'age' => 28], ['name' => 'Bob', 'age' => 35]]

In this example, we have created a collection of users with their names and ages. We then used the where method to filter the collection, only returning users who are older than 25. Finally, we used the sortBy method to sort the filtered collection by name.

Another useful method of collections in Laravel is the map method. This method allows developers to transform the values in a collection by applying a callback function to each item in the collection. Here's an example of how we can use the map method to transform a collection of users into a collection of their full names:

$users = collect([
    ['first_name' => 'John', 'last_name' => 'Doe'],
    ['first_name' => 'Jane', 'last_name' => 'Smith'],
    ['first_name' => 'Bob', 'last_name' => 'Johnson']
]);

$fullNames = $users->map(function ($user) {
    return $user['first_name'] . ' ' . $user['last_name'];
});

// Output: ['John Doe', 'Jane Smith', 'Bob Johnson']

In this example, we have used the map method to create a new collection of full names by concatenating the first name and last name of each user in the original collection.

Primitive & Non-Primitive Data Types

Code Of Accuracy — Wed, 05 Apr 2023 11:16:25 +0000

In JavaScript, data types can be broadly classified into two categories: primitive and non-primitive data types. Understanding these data types is crucial for writing effective and efficient code. In this article, we will explore primitive and non-primitive data types in JavaScript, along with examples.

Primitive Data Types

Primitive data types in JavaScript are simple data types that are not objects and do not have methods. They are immutable, which means that their values cannot be changed once they are created. There are six primitive data types in JavaScript.

1. String: A string is a collection of characters that are enclosed within single or double quotes. For example:

let name = 'John Doe';

2. Number: A number is a numerical value, which can be either positive, negative, or with decimal points. For example:

let age = 25;
let salary = 50000.50;

3. Boolean: A boolean data type can have only two values - true or false. For example:

let isMarried = true;

4. Null: Null represents a null or empty value. For example:

let address = null;

5. Undefined: Undefined represents a variable that has not been assigned a value. For example:

let gender;

6. Symbol: A symbol is a unique and immutable data type that is used to identify object properties. For example:

const mySymbol = Symbol('mySymbol');

Non-Primitive Data Types

Non-primitive data types in JavaScript are complex data types that are objects and can have methods. They are mutable, which means that their values can be changed. There are three non-primitive data types in JavaScript:

1. Object: An object is a collection of key-value pairs, where the key is a string and the value can be any data type. For example:

const person = {
  name: 'John Doe',
  age: 25,
  isMarried: true
};

2. Array: An array is a collection of elements, which can be of any data type. The elements are indexed and can be accessed using the index number. For example:

const numbers = [1, 2, 3, 4, 5];

3. Function: A function is a block of code that can be invoked or called to perform a specific task. It can accept parameters and return a value. For example:

function addNumbers(num1, num2) {
  return num1 + num2;
}

Laravel Job/Queue

Code Of Accuracy — Tue, 28 Mar 2023 11:17:09 +0000

Laravel provides a powerful job and queue system that allows you to execute time-consuming tasks asynchronously in the background, freeing up your application to handle other requests. Jobs represent individual units of work that can be executed independently, and queues are used to organize and prioritize jobs.

Here are the basic steps involved in using Laravel's job and queue system:

Step 1: Create a Job
To create a job in Laravel, you can use the php artisan make:job command. This will create a new PHP class file in the app/Jobs directory, which represents the job.

php artisan make:job SendEmailJob

You can then define the handle method in the job class, which contains the logic for the job. This method is executed when the job is dispatched and processed by the queue worker.

public function handle()
{
    // Send email logic here
}

Step 2: Dispatch the Job
To dispatch a job in Laravel, you can use the dispatch function. This function takes a job instance as its argument and adds the job to the queue.

SendEmailJob::dispatch();

You can also chain additional methods to the dispatch function to configure the job, such as specifying a delay or a specific queue to use.

SendEmailJob::dispatch()->delay(now()->addMinutes(10))->onQueue('emails');

Step 3: Process the Queue
To process the queue in Laravel, you need to start the queue worker using the php artisan queue:work command. This command starts a long-running PHP process that continuously polls the queue for new jobs to process.

php artisan queue:work

The queue worker executes each job by calling its handle method, and then marks the job as completed. If an error occurs while processing a job, the worker will retry the job a certain number of times before moving it to the failed job queue.

Conclusion

Laravel's job and queue system is a powerful feature that can greatly improve the performance and scalability of your applications. By executing time-consuming tasks asynchronously in the background, your application can handle more requests and respond more quickly to users. With just a few simple steps, you can create, dispatch, process, and monitor jobs in Laravel.

_Github : Practical for Job/Queue : _
https://github.com/codeofaccuracy/laravel-job-queue

Note: You can just follow the README.md file.

Thanks for Reading.....

Collection VS Array

Code Of Accuracy — Mon, 27 Mar 2023 13:10:12 +0000

Collection VS Array & When To Use Which

In Laravel, Arrays and Collections are both used for storing and manipulating sets of data. However, they have some key differences in terms of functionality and performance. Here's a brief overview of arrays and collections in Laravel, along with some examples of when to use each one:

Arrays:

An array is a basic data structure that stores a set of values, indexed by a numeric key.
Laravel provides a number of helper functions for working with arrays, including array_map(), array_filter(), and array_reduce().
Arrays are generally faster and use less memory than collections, especially for small datasets.

When to use:
Arrays are a good choice when you have a simple dataset that you need to iterate over quickly. For example, if you're working with a small set of numeric values, you might use an array to store them.

Example:

$numbers = [1, 2, 3, 4, 5];
$filtered_numbers = array_filter($numbers, function($num) {
    return $num % 2 == 0;
});

Collections:

A collection is an object-oriented version of an array, with additional methods and functionality for working with the data.
Laravel's collection class provides a wide range of helper methods for filtering, transforming, and sorting data, such as map(), filter(), and sortBy().
Collections are generally slower and use more memory than arrays, especially for large datasets. However, they provide more functionality and flexibility.

When to use:
Collections are a good choice when you need to work with more complex datasets that require filtering, sorting, or transformation. For example, if you're working with a collection of database records, you might use a collection to filter the records by certain criteria and then sort them by date. Collections are also useful when you need to chain multiple operations together, as the fluent interface makes it easy to do so.

Example:

$users = App\Models\User::all();
$admins = $users->filter(function ($user) {
    return $user->isAdmin();
});
$names = $admins->map(function ($user) {
    return $user->name;
});

HAVING Clause In MySQL

Code Of Accuracy — Mon, 27 Mar 2023 11:11:00 +0000

The HAVING clause is used in MySQL to filter the results of a query based on a condition that involves an aggregate function. This clause is used after the GROUP BY clause to filter the grouped data based on the result of the aggregate function.

Syntax:

SELECT column1, column2, aggregate_function(column_name)
FROM table_name
WHERE condition
GROUP BY column1, column2
HAVING aggregate_function(column_name) condition;

The HAVING clause is similar to the WHERE clause, but the WHERE clause filters the rows before the data is grouped, while the HAVING clause filters the groups after the data is grouped.

Example:

Let's consider the following table named orders:

OrderID	CustomerID	OrderDate	TotalAmount
1	1	2022-01-01	100
2	2	2022-01-02	200
3	1	2022-01-03	300
4	2	2022-01-04	400
5	3	2022-01-05	500

If we want to find the total amount of orders for each customer and only show the results for customers who have ordered more than 300 dollars, we can use the following query:

SELECT CustomerID, SUM(TotalAmount) as Total
FROM orders
GROUP BY CustomerID
HAVING SUM(TotalAmount) > 300;

The result will be:

CustomerID	Total
1	400
2	600

As you can see, the HAVING clause is used to filter the result set based on the aggregate function SUM(TotalAmount), which calculates the total amount of orders for each customer. The condition SUM(TotalAmount) > 300 filters out the customers who have ordered less than 300 dollars.

MySQL joins

Code Of Accuracy — Mon, 27 Mar 2023 10:18:20 +0000

MySQL joins are used to combine rows from two or more tables based on a related column between them. Joins are essential for retrieving data from multiple tables in a single query. In this article, we will discuss different types of joins in MySQL with examples.

Types of Joins in MySQL:

1. INNER JOIN: An inner join returns only the matching rows from both tables. It returns the rows that have matching values in both tables.

Syntax:

SELECT table1.column1, table2.column2...
FROM table1
INNER JOIN table2
ON table1.column_name = table2.column_name;

Example:

Consider two tables employees and departments:

Table: employees

emp_id	emp_name	emp_salary	dept_id
101	John	50000	1
102	Smith	60000	2
103	Mary	55000	1
104	Joe	45000	2

Table: departments

dept_id	dept_name
1	HR
2	IT

To join these tables based on dept_id column:

SELECT employees.emp_name, departments.dept_name
FROM employees
INNER JOIN departments
ON employees.dept_id = departments.dept_id;

Output:

emp_name	dept_name
John	HR
Smith	IT
Mary	HR
Joe	IT

2. LEFT JOIN: A left join returns all the rows from the left table and matching rows from the right table. If there is no matching row in the right table, it returns null.

Syntax:

SELECT table1.column1, table2.column2...
FROM table1
LEFT JOIN table2
ON table1.column_name = table2.column_name;

Example:

Consider two tables students and grades:

Table: students

student_id	student_name
101	John
102	Smith
103	Mary
104	Joe

Table: grades

student_id	grade
101	A
102	B
104	A

To join these tables based on student_id column:

SELECT students.student_name, grades.grade
FROM students
LEFT JOIN grades
ON students.student_id = grades.student_id;

Output:

student_name	grade
John	A
Smith	B
Mary	NULL
Joe	A

3. RIGHT JOIN: A right join returns all the rows from the right table and matching rows from the left table. If there is no matching row in the left table, it returns null.

Syntax:

SELECT table1.column1, table2.column2...
FROM table1
RIGHT JOIN table2
ON table1.column_name = table2.column_name;

Example:

Consider two tables employees and departments:

Table: employees

emp_id	emp_name	emp_salary	dept_id
101	John	50000	1
102	Smith	60000	2
103	Mary	55000	1

View In MySQL

Code Of Accuracy — Sat, 25 Mar 2023 11:57:04 +0000

A view is a virtual table that is based on the result of a SELECT statement. Views are used to simplify complex queries by providing a way to create a logical representation of the data in a database. Once a view is created, it can be used like any other table in the database.

To create a view in MySQL, you can use the CREATE VIEW statement. Here's the basic syntax:

CREATE VIEW view_name AS
SELECT column1, column2, ...
FROM table_name
WHERE condition;

Here, view_nameis the name you want to give to your view, table_name is the name of the table you want to base your view on, and column1, column2, etc. are the columns you want to include in your view. You can also include a WHERE clause to filter the data that's included in your view.

For example, let's say you have a table called customers with columns id, name, and email. You could create a view that includes only the id and name columns like this:

CREATE VIEW customer_names AS
SELECT id, name
FROM customers;

Once you've created a view, you can use it in your queries just like you would any other table. For example, you could run a query to select all the customers from the customer_names view like this:

SELECT * FROM customer_names;

This would return a result set with just the id and name columns from the customers table.

Indexing In MySQL

Code Of Accuracy — Sat, 25 Mar 2023 11:46:51 +0000

Indexing in MySQL is a technique used to optimize the database performance by creating a data structure that provides fast access to the rows in a table. An index is essentially a data structure that is used to speed up the retrieval of data from a table. It works by creating a separate structure that contains a subset of the data in the table, along with pointers to the corresponding rows in the table.

An index is similar to an index in a book or a library. It helps you find the data you need more quickly by providing a map to the data. Without an index, MySQL would have to search through every row in a table to find the data you need, which can be a time-consuming and resource-intensive process.

To create an index in MySQL, you can use the CREATE INDEX statement. For example, let's say we have a table called employees with columns for id, name, and department. We can create an index on the name column using the following SQL statement:

CREATE INDEX idx_name ON employees (name);

This statement creates an index called idx_name on the name column of the employees table. The index will contain a subset of the data in the name column, along with pointers to the corresponding rows in the table.

Once the index is created, MySQL will use it to speed up queries that involve the name column. For example, if we want to find all employees with the name John, we can use the following SQL statement:

SELECT * FROM employees WHERE name = 'John';

It's important to note that while indexing can greatly improve the performance of your database, it can also have some downsides. Indexes take up space on disk and in memory, so creating too many indexes can have a negative impact on performance. Additionally, indexes need to be updated every time the table they're associated with is updated, which can also impact performance.

In conclusion, indexing in MySQL is a powerful technique that can greatly improve the performance of your database. By creating an index on a column or set of columns, you can speed up queries and reduce the amount of time it takes to retrieve data from your tables. However, it's important to use indexes judiciously and be mindful of their impact on performance.

Lazy Loading & Eager Loading

Code Of Accuracy — Sat, 25 Mar 2023 10:45:11 +0000

In Laravel, lazy loading and eager loading are two techniques for fetching related data from a database. Understanding the differences between these two techniques can help developers optimize their application's performance and prevent unnecessary database queries.

Eager Loading
Eager loading is a technique that allows developers to load related data along with the main model. It is best used when a developer knows that they will need to access the related data and wants to minimize the number of database queries needed. Eager loading is achieved using the with method in Laravel.

For example, suppose we have a Post model that has many Comments and we want to display all posts and their comments on a page. Without eager loading, we would need to perform a separate database query for each post to retrieve its comments. With eager loading, we can use the with method to load all comments along with the posts in a single query:

$posts = Post::with('comments')->get();

Lazy Loading
Lazy loading, on the other hand, is a technique that delays the loading of related data until it is actually needed. It is best used when a developer is unsure whether they will need to access the related data and wants to minimize the initial database queries. In Laravel, lazy loading is achieved using lazy relationships or by accessing the related data through a magic property on the model.

The n+1 problem occurs in lazy loading when you load related data in a loop. For example, if you have a view that displays a list of Users and the number of Posts each User has.

For example, suppose we have a User model that has many Posts and we want to display all users and their posts on a page. With lazy loading, we would retrieve all users first, and then use lazy loading to retrieve each user's posts only when they are needed:

$users = User::all();

foreach ($users as $user) {
    foreach ($user->posts as $post) {
        // do something with the post
    }
}

In this example, lazy loading is used to retrieve each user's posts only when they are needed, which minimizes the number of initial database queries.

To solve the n+1 problem, you can use eager loading instead of lazy loading. You can modify your query to fetch all the related Posts at once.

What is Override And Extensions

Code Of Accuracy — Fri, 24 Mar 2023 07:07:34 +0000

In object-oriented programming, overriding and extensions are common concepts that allow developers to modify or enhance the behavior of existing classes or methods. In this article, we'll explore these concepts in the context of PHP, with examples to demonstrate their usage.

1. Overriding in PHP

Overriding is the process of redefining a method in a subclass that was already defined in the parent class. This allows the subclass to provide its own implementation of the method, which may be different from the parent class.

Consider the following example:

class Animal {
  public function makeSound() {
    echo "The animal makes a sound";
  }
}

class Cat extends Animal {
  public function makeSound() {
    echo "Meow!";
  }
}

$cat = new Cat();
$cat->makeSound(); // Outputs "Meow!"

In this example, we have a base class Animal that defines a makeSound() method. The Cat class extends Animal and overrides the makeSound() method with its own implementation that outputs Meow!.

When we create an instance of Cat and call makeSound(), the overridden implementation in Cat is executed instead of the one in Animal.

2. Extensions in PHP

Extensions, also known as method chaining, is a technique that allows developers to add functionality to an object by chaining method calls together. This can make code more concise and easier to read.

Consider the following example:

class Car {
  private $model;

  public function setModel($model) {
    $this->model = $model;
    return $this;
  }

  public function setColor($color) {
    $this->color = $color;
    return $this;
  }

  public function setYear($year) {
    $this->year = $year;
    return $this;
  }
}

$car = new Car();
$car->setModel("Tesla")
    ->setColor("Red")
    ->setYear(2022);

In this example, we have a Car class with three setter methods that set the model, color, and year properties of the car. Each method returns $this, allowing the methods to be chained together.

When we create a new instance of Car and call the setter methods, we can chain them together to set all three properties in a single line of code.

In PHP, overriding and extensions are powerful techniques that allow developers to modify or enhance the behavior of existing classes or methods. By understanding these concepts and using them effectively, you can write more flexible and maintainable code.