Forem: Jamir Hossain

JavaScript Execution Context – How JS Code Runs Behind the Scenes

Jamir Hossain — Sat, 04 Jan 2025 05:53:48 +0000

Before understanding what JavaScript Execution Context is, we need to know how and in which environments we can run JavaScript code.

First of all, we can run JavaScript in two environments:

Through the Browser
Through the Node.js

How does JavaScript code run on our computer?

When we write JavaScript code on our computer and then try to run it, the code first goes to either the Browser or Node.js.

However, the JavaScript code we write is not directly understood by the Browser or Node.js. At this point, both send the code to the JavaScript Engine built into them. There are different types of engines, for example:

V8 Engine in Google Chrome,
SpiderMonkey in Mozilla Firefox,
V8 Engine in Node.js, etc.

Next, the JavaScript Engine compiles the JavaScript code into machine code. This machine code is then sent to the computer, which executes it, and we see the output displayed.

As programmers, we need to have a good understanding of this intermediate step, i.e., how the JavaScript Engine compiles JavaScript code into machine code.

So, now we need to understand how the JavaScript Engine works. The JavaScript Engine works in two ways to convert code into machine code. First one is Interpretation and the second one is Compilation. So, what are Interpretation and Compilation?

What is Interpretation, and How Does it Work?

Interpretation is the process of reading all the source code written in a high-level language line by line and converting each line into machine code immediately after reading it. If there is an error while reading a line of code, the process stops right there, making it easy for the programmer to identify the error. This makes debugging straightforward. However, since this process reads the code line by line, it is comparatively slower.

What is Compilation, and How Does it Work?

Compilation is the process of converting all the source code written in a high-level language into machine code at once. In this case, even if there are errors in the code, it will still compile and only show errors at runtime. As a result, it becomes harder for the programmer to identify the errors, making debugging more challenging. However, since the entire source code is converted into machine code at once, this process is comparatively faster. So now, the question arises: Is JavaScript a compiled or an interpreted language?

Is JavaScript a Compiled or an Interpreted Language?

Initially, JavaScript was primarily considered an interpreted language. However, since this process was quite slow, modern JavaScript engines began using a new technique that combines both interpretation and compilation, known as Just-In-Time (JIT) Compilation. This process combines interpretation and compilation to convert code into machine code. As a result, it is much faster and easier to debug compared to older methods.

To understand how JavaScript’s Just-In-Time (JIT) Compilation works, we need to understand JavaScript’s Execution Context. Let’s now try to understand JavaScript’s Execution Context.

JavaScript Execution Context

First, take a look at the following code example.

Code Example

var a = 1;

function one() {
  console.log(a);

  function two() {
    console.log(b);

    var b = 2;

    function three(c) {
      console.log(a + b + c);
    }

    three(4);
  }

  two();
}

one();

Output

1
undefined
7

When we ran the code, we tried to print the b variable before it was declared inside the two() function, and the output was undefined. However, no error occurred. The question arises: how did the b variable have the value undefined? The answer lies in the JavaScript Execution Context. Now, we will explore JavaScript Execution Context in more detail.

There are two types of Execution Context in JavaScript:

Global Execution Context
Function Execution Context

Each Execution Context goes through two phases: Creation Phase and Execution Phase.

Global Execution Context

When we run JavaScript code, the first thing that happens is the Global Execution Context. This context first goes through its Creation Phase, where several things happen:

Creation Phase

A Global Object is created.
A this object is created and assigned the value of the Global Object.
A Variable Object is created, where all functions and variables are declared. The variables are assigned undefined as their value, and the functions are assigned references to their respective functions.

Once the Creation Phase completes, the Global Execution Context moves to the next phase: Execution Phase, where more steps occur.

Execution Phase

The variables that were declared in the Creation Phase and initialized with undefined are now assigned their respective values.
The functions declared in the Creation Phase, which were stored as references, are now called and executed.

Function Execution Context

When the functions referenced during the Execution Phase of the Global Execution Context are called, each function creates its own Function Execution Context. Just like the Global Execution Context, the Function Execution Context also goes through a Creation Phase, where several steps occur:

Creation Phase

A parameter object is created for the function.
A this object is created and assigned the value of the Global Object.
A Variable Object is created, where all functions and variables are declared. The variables are assigned undefined as their value, and the functions are assigned references to their respective functions.

Once the Creation Phase is completed, the Function Execution Context moves to the Execution Phase, where more steps occur.

Execution Phase

The variables declared in the Creation Phase, which were initialized with undefined, are now assigned their respective values.
The functions declared in the Creation Phase are now called and executed.

Function Execution Context in Nested Functions

When functions are called within other functions, a new Function Execution Context is created for each of these functions. Each Function Execution Context then goes through both the Creation Phase and Execution Phase. This process continues for each function called inside another function, and each function will go through these phases separately.

Let's look at the diagram below.

We have seen that both the Global Execution Context and Function Execution Context go through certain steps. The only difference is that, in the Global Execution Context, the first step is to create the global object, whereas, in the Function Execution Context, the first step is to create a parameter object for the function.

Now, the question arises: how does JavaScript manage these Execution Contexts when they are created for both the global context and each function?

Managing Execution Contexts with the Execution Stack

To manage these contexts, JavaScript uses a data structure called the Execution Stack. The Execution Stack stores contexts in a stack-like manner: first, the Global Execution Context, followed by each Function Execution Context. When all the execution contexts are stored in the stack, JavaScript processes them one by one, starting from the top of the stack.

Scoping with `let` and `const`

It is important to note that when we declare variables with let or const inside a global or function scope, these variables are not stored in the Variable Object during the Creation Phase, and they are not initialized with undefined. Instead, these variables are directly declared and assigned their values in the Execution Phase.

Consider the following code example:

Code Example

function two() {
  console.log(b);

  const b = 2;
}

two();

If we run this code, we will encounter a ReferenceError. This is because we are trying to print the value of the b variable before declaring it, and since b is declared using const, it behaves differently from regular variables. Variables declared with const or let are not stored in the Variable Object during the Creation Phase, which is why we get an error when trying to access them before they are assigned a value.

Conclusion

I hope this explanation of how JavaScript works and what happens during its Execution Context phases has provided you with a clearer understanding. In the next lesson, we will explore another JavaScript topic.

You can connect with me on GitHub and Linkedin.

PHP OOP Part-2: Constructor and Destructor

Jamir Hossain — Thu, 02 Jan 2025 16:54:46 +0000

In this series, I will cover the fundamentals of PHP Object-Oriented Programming (OOP). The content will be organized into sequential parts, each focusing on a specific topic. If you're a beginner or unfamiliar with OOP concepts, this series is designed to guide you step by step. In this part, I will discuss about the constructor and destructor in PHP. Let's begin the journey of learning PHP OOP together!

What is a Constructor?

Let’s first try to understand that what is a Constructor? In simple terms, the constructor is a special method that is automatically called when an object of a class is created. The constructor is used to initialize the properties of the object. It is a magic method in PHP. But now we need to understand about the constructor in detail. Let’s first look at an example of code.

Code Example

class Car
{
   public $name;
   public $color;

   public function setValue(string $name, string $color)
   {
      $this->name  = $name;
      $this->color = $color;
   }

   public function getValue()
   {
      echo "Car name: $this->name\n";
      echo "Car color: $this->color\n";
   }
}

$toyota = new Car;
$toyota->setValue('Toyota', 'Red');
$toyota->getValue();

In the above example, or in the previous section, we set the value of an object using a method. This is called a Setter Method, it means that after creating an object of a class, if we set the value using a method of that object, it is referred to as a Setter Method. However, we can simplify this process using PHP’s built-in magic method. This method is called the constructor, and in PHP, it is defined using __construct(). Let’s look at the following example.

Code Example

class Car
{
   public $name;
   public $color;

   function __construct(string $name, string $color)
   {
      $this->name  = $name;
      $this->color = $color;
   }

   public function getValue()
   {
      echo "Car name: $this->name\n";
      echo "Car color: $this->color\n";
   }
}

$toyota = new Car('Toyota', 'Red');
$toyota->getValue();

In this example, instead of using the setValue method, we’ve used the __construct() method. So, what’s the advantage of using __construct()? In the previous example, after creating an object of the Car class, we had to pass the value for each car using the setValue method. But now, by using __construct(), we can pass the value at the time of object creation, and we don't have to call an additional method.

But now, the question arises: We didn’t call __construct(), so how did it receive the value and set it to the variable?

Code Example

new Car('Toyota', 'Red');

When we use __construct() inside a class, and that constructor receives values from outside, we can pass the values in the first bracket when creating the class object. As soon as we create the object in this way, the __construct() method is automatically called. In other words, whenever we create an instance of a class, the __construct() method it will instantly call. This is how we can initialize the properties of an object using the constructor. Since __construct() is a magic method, so we don’t need to call it explicitly. It will run automatically in specific scenarios to perform certain tasks.

What is a Destructor?

A destructor is also a magic method in PHP. When we create an object using a class, we perform various tasks with that object. But when the tasks are completed, it means the destructor will be triggered when the object is destroyed. The destructor is defined in PHP using __destruct().

Here, it’s important to note that if we create multiple objects using a class, the __destruct() method will be called for each object when all of them are destroyed. In other words, the __destruct() method will be called as many times as the number of objects created using that class. Let’s look at the following example.

Code Example

class Car
{
   public $name;
   public $color;

   function __construct(string $name, string $color)
   {
      $this->name  = $name;
      $this->color = $color;
   }

   public function getValue()
   {
      echo "Car name: $this->name\n";
      echo "Car color: $this->color\n";
   }

   function __destruct()
   {
      echo "I have called\n";
   }
}

$toyota = new Car('Toyota', 'Red');
$toyota->getValue();

$tesla = new Car('Zip', 'Blue');
$tesla->getValue();

If we run this code, we will see the following output.

Car name: Toyota
Car color: Red
Car name: Zip
Car color: Blue
I have called
I have called

Now, you might be wondering in which cases we should use the __destruct() method. When we work with files or databases, we need to open them, but once our tasks are completed, then we need to close the file or database. In such cases, we can use the __destruct() method. Additionally, there are many real-life use cases for the __destruct() method.

I hope now we have some understanding of __construct() and __destruct(). Apart from these methods, there are other important magic methods in PHP, such as __call(), __callStatic(), etc. We can use these methods as well, as they perform certain tasks in various scenarios within a class.

So, that’s all for today. We’ll talk more about another topic in the next lesson. Stay tuned! Happy coding!

PHP OOP Part-1: Introduction, Object, and Class

Jamir Hossain — Thu, 02 Jan 2025 16:52:35 +0000

In this series, I will cover the fundamentals of PHP Object-Oriented Programming (OOP). The content will be organized into sequential parts, each focusing on a specific topic. If you're a beginner or unfamiliar with OOP concepts, this series is designed to guide you step by step. In this part, I will discuss about the OOP introduction, object and class in PHP. Let's begin the journey of learning PHP OOP together!

Introduction

Software is essentially a program created to perform specific tasks on a computer. A program consists of several instructions written to achieve the program’s intended purpose. These instructions follow certain methods and styles, which are known as programming paradigms. There are several programming paradigms, such as:

Imperative
Declarative
Procedural
Functional
Object-Oriented (OOP), etc.

However, in this series, we will focus on understanding the Object-Oriented Programming paradigm in PHP.

PHP has supported Procedural Programming from the very beginning. Additionally, PHP can also be used for Functional Programming. But in 2004, with PHP version 5, OOP was introduced, allowing PHP to be used as an object-oriented programming language.

In this section, we will discuss the most important terms of Object-Oriented Programming System (OOP). We will try to understand each of these terms gradually.

What is an Object?

In our daily life, everything we see around us can be considered as an object. To identify objects more easily, we can think of them as nouns. For example, Man, Animal, Car, etc., are nouns, so we can refer to them as objects.

An object has various characteristics, such as:

Properties:
Properties of an object represent its attributes or features. For example, a car's properties could include its name, size, color, weight, etc.
Actions/Behaviors/Methods:
Actions, behaviors, or methods represent what an object can do. For instance, a car's behavior might include starting, stopping, or running.

Now for example, If we consider a Car object then we will find it's Properties and Behaviors.

Properties: color, size, weight, name, etc.
Behaviors: carCanStart(), carCanStop(), carCanRun(), etc.

How to Create an Object in PHP?

In PHP, to create an object, we first need to use a class. What is a class? We'll learn about that shortly. Meanwhile, consider the following example:

Code Example:

class Vehicle
{
   public $name;
   public $color;

   public function setValue(string $name, string $color)
   {
      $this->name  = $name;
      $this->color = $color;
   }

   public function getValue()
   {
      echo "Car name: $this->name\n";
      echo "Car color: $this->color\n";
   }
}

$toyota = new Vehicle;
$toyota->setValue('Toyota', 'Red');
$toyota->getValue();

In this example, we can see that we have created an object named $toyota using a class called Vehicle. Here, to create the object, we used the new keyword. This is a built-in PHP keyword used to create a new object from a class.

In this way, we can create as many objects as needed. As mentioned earlier, an object should have certain characteristics. In our example, we can observe that the created object contains these characteristics, such as having properties and methods (or actions), among other features.

What is a Class?

A class is a template or blueprint which is used to create objects. When we create a class, we define its properties and methods, which can be used when objects are created of that class. Here’s an example of a simple class.

Code Example

class Car
{
   public $name;
   public $color;

   public function setValue(string $name, string $color)
   {
      $this->name  = $name;
      $this->color = $color;
   }

   public function getValue()
   {
      echo "Car name: $this->name\n";
      echo "Car color: $this->color\n";
   }
}

$toyota = new Car;
$toyota->setValue('Toyota', 'Red');
$toyota->getValue();

$tesla = new Car;
$tesla->setValue('Zip', 'Blue');
$tesla->getValue();

In the code above, we see that using the Car class, we created two objects. This means that with the same class, we can create many objects (such as many car objects). In this sense, the Car class works like a blueprint.

I hope you now have a basic understanding of the concepts discussed in this section. In the next lesson, we will continue to explore more about Object-Oriented Programming.

PHP OOP Part-7: Composition vs Inheritance and Dependency Injection

Jamir Hossain — Thu, 02 Jan 2025 16:45:58 +0000

In this series, I will cover the fundamentals of PHP Object-Oriented Programming (OOP). The content will be organized into sequential parts, each focusing on a specific topic. If you're a beginner or unfamiliar with OOP concepts, this series is designed to guide you step by step. In this part, I will discuss about the Composition vs Inheritance and Dependency Injection in PHP. Let's begin the journey of learning PHP OOP together!

Composition vs Inheritance

We have already learned about the relationship between parent and child classes in object-oriented programming, where we saw that a child class can inherit a parent class and access everything from it. This is known as Inheritance.

On the other hand, Composition refers to assigning a parent class as a property value in the child class, rather than inheriting it. Through this, we can access everything from the parent class. This is known as Composition.

Below are examples illustrating Composition and Inheritance.

Code Example

class Link
{
   public string $name;
   public string $type;

   public function create($name, $type)
   {
      $this->name = $name;
      $this->type = $type;
   }

   public function show()
   {
      echo "name: $this->name, type: $this->type";
   }
}


// Inheritance example
class ShoLink extends Link
{
   // other functionalities
}


// Composition example
class User
{
   public Link $link;

   public function __construct()
   {
      $this->link = new Link();
   }
   // other functionalities
}

$user = new User();
$user->link->create("Jamir", "Short");

In the first example, we can see that the ShoLink class inherits the Link class. On the other hand, in the second example, the User class does not inherit the Link class. Instead, it assigns an instance of the Link class to one of its properties. As a result, we can access everything from the Link class in both child classes.

Now, a question might arise: if we can already access everything by using inheritance, why should we use composition? After all, with composition, we need to declare an additional property and set its value via construction. This seems like extra work—so what’s the benefit of using composition?

Well, we know that inheritance makes everything in the parent class accessible in the child class. Consequently, even if we don’t want to use certain methods of the parent class or if some properties or methods of the parent class are not needed in the child class, they still become accessible in the child class if they are public or protected members.

To solve this issue, composition is used. With composition, we can make only the required parts of the parent class accessible in the child class. Let’s clarify this further with another example.

If we look closely at the Link class, we can see that it has a show method. Using this method, we can directly display the link created in the ShoLink class.

However, what if we want the User class to prevent anyone from directly viewing the link created for the user? Instead, we might want to display the user’s link alongside their profile.

This is why, in the User class, instead of inheriting the Link class, we are accessing it through composition. As a result, no one can directly view the user’s link through the User class, but they can directly view the ShoLink class’s link.

Favor Composition over Inheritance

Now we have some understanding of composition and when to use it instead of inheritance to solve certain problems. In OOP, there is a principle called "Favor Composition over Inheritance", which means prioritizing composition over inheritance. In other words, for child classes where it’s not necessary to access everything from the parent class, we should always prefer composition over inheritance.

Now, the question arises: how do we decide when to use composition and when to use inheritance?

In this case, we need to base our decision on two types of relationships:

is a -> relationship. If the relationship is “is a”, we should use inheritance.
has a -> relationship. If the relationship is “has a”, we should use composition.

Code Example

// Inheritance example
class ShoLink extends Link
{
   // other functionalities
}

If you look at the example of the ShoLink class above, you'll see that the ShoLink class is inheriting from the Link class. So, if I were to define a relationship between them, the relationship would be ShoLink is a Link because ShoLink is essentially a type of Link.

Code Example

// Composition example
class User
{
   public Link $link;

   public function __construct()
   {
      $this->link = new Link();
   }
   // other functionalities
}

Now, if we look at the example of the User class above, we can see that the User class is using composition with the Link class. So, if I were to define a relationship between them, the relationship would be User has a Link because a User is not a Link, but a User can have a Link or may possess one.

I hope now you have a clearer understanding of composition and inheritance, including when to use each one and which one to prioritize in different situations.

Dependency Injection

Before understanding dependency injection, we need to first understand what a dependency is. A dependency is when a child class uses the members of another class, either by inheritance or composition. In that case, the parent class becomes the dependency of the child class.

In the example above, we saw that when we use composition instead of inheritance, we need to declare a property in the child class and assign the parent class's instance to that property via the constructor. Therefore, if we want to use the User class, we must instantiate the Link class in its constructor because the User class is dependent on the Link class. In other words, the Link class is a dependency for the User class. The issue here is that the instantiation process of the Link class is tightly coupled within the User class.

The problem is that the instantiation of the Link class is limited and specific to the User class. If we want to pass any other class instead of the Link class from the outside into the User class, we cannot do that because we are explicitly creating the instance of the Link class in the constructor and assigning it to the Link property. This is called a Tightly Coupled Dependency, meaning we cannot change this dependency from outside.

However, if we do not instantiate the Link class ourselves in the constructor and instead leave it to the user, meaning when a user uses our User class, they will pass the Link class dependency into the User class, our problem will be solved.

Let's look at the code example below.

Code Example

// Composition example
class User
{
   public Link $link;

   public function __construct(Link $link)
   {
      $this->link = $link;
   }
   // other functionalities
}

// Dependency Injection example
$user = new User(new Link());
$user->link->create("Jamir", "Short");

In this example, we can see that instead of instantiating the Link class in the constructor of the User class, we are passing the dependency of the Link class into the User class from the outside. This process of passing the dependency into the User class via the user is called Dependency Injection. In other words, we are injecting or pushing the Link class's dependency from the outside. This is known as a Loosely Coupled Dependency, meaning we can easily change this dependency from outside.

Now, if the Link class also has its own dependencies, we can also inject those dependencies into it from the outside via the User class. Then, we can simply inject the instance of the Link class into the User class. As a result, we don’t need to worry about the Link class’s dependencies within the User class, because the user will handle it from the outside.

Let’s look at the code example below.

Code Example

// Composition example
class User
{
   public Link $link;

   public function __construct(Link $link)
   {
      $this->link = $link;
   }
   // other functionalities
}

// Dependency Injection example
$link = new Link(new Visitor());
$user = new User($link);
$user->link->create("Jamir", "Short");

This way, we can inject as many dependencies as we want from the outside, and it will be much more flexible. That’s all for today; we’ll talk in the next lesson.

You can connect with me on GitHub and Linkedin.

PHP OOP Part-6: Polymorphism

Jamir Hossain — Thu, 02 Jan 2025 16:44:34 +0000

In this series, I will cover the fundamentals of PHP Object-Oriented Programming (OOP). The content will be organized into sequential parts, each focusing on a specific topic. If you're a beginner or unfamiliar with OOP concepts, this series is designed to guide you step by step. In this part, I will discuss about the Polymorphism in PHP. Let's begin the journey of learning PHP OOP together!

Now we will learn about polymorphism. What does polymorphism mean? The term "Polymorphism" has two parts. One is "Poly," which means many, and the other is "Morphism," which means forms. So, polymorphism means many forms or various forms. In the context of programming, when the term polymorphism is used, we can achieve it using two concepts.

The first concept is Method Overloading, which is also known as Compile-Time Polymorphism.

Method overloading works like this: Suppose we have a method in a class that takes one parameter. If we declare another method with the exact same name but with multiple parameters, it is valid. That means we can declare two methods with the same name in a class, but the number of parameters must be different. Later, when we create an instance of this class and use these methods, the decision of which method to call will depend on how many parameters are passed to it. As a result, the same method will behave or act differently based on the parameters. Now let’s take a look at an example code.

Code Example

class Vehicle
{
   public function getTotal($first, $second)
   {
      echo $first . " " . $second . "\n";
   }

   public function getTotal($first, $second, $third)
   {
      echo $first . " " . $second . " " . $third . "\n";
   }
}

$vehicle = new Vehicle();
$vehicle->getTotal(10, 20);
$vehicle->getTotal(10, 20, 30);

Here we can see that two methods named getTotal have been declared in the Vehicle class. These two methods take different parameters. Now, when we create an instance of the Vehicle class and use these methods, their behavior depends on the parameters provided. For example, after creating an instance of the Vehicle class, the getTotal method is first called with 2 parameters, resulting in the first getTotal method of the class being called. Then, the getTotal method is called again with 3 parameters, causing the second getTotal method of the class to be called. So, we can understand how the same method can behave differently.

However, if you run this code, it won’t work because PHP does not support method overloading or compile-time polymorphism. But it does support method overriding or runtime polymorphism. We only used this example to understand the concept theoretically.

The second concept is Method Overriding, also known as Runtime Polymorphism.

Method overriding works as follows: Suppose there is a method in a class that may or may not take parameters and performs a specific task. If this class is inherited by another class, and a method with the exact same name is declared in the child class, this process is called method overriding or runtime polymorphism. In other words, we can declare a method with the same name in the child class, and the number of parameters can be the same or different. It will perform a different task. Later, when we create an instance of the child class and use the method, the decision of whether to call the method from the parent or child class will depend on the parameters passed. As a result, the same method will exhibit different behaviors or actions based on the parameters. Now let’s take a look at an example code.

Code Example

class Vehicle
{
   public function getTotal($first, $second)
   {
      echo $first . " " . $second . "\n";
   }
}

class Car extends Vehicle
{
   public function getTotal($first, $second, $third = null)
   {
      echo $first . " " . $second . " " . $third . "\n";
   }
}

$vehicle = new Car();
$vehicle->getTotal(10, 20);
$vehicle->getTotal(10, 20, 30);

When the getTotal method is called with two parameters from the instance of the child class, it checks at runtime if such a method with two parameters exists in the child class. If not, the child class will inherit and call the method from its parent class.

Later, when the getTotal method is called again with three parameters, it checks once more if a method with three parameters exists in the child class. Upon finding that the method has been overridden in the child class with three parameters, it calls the getTotal method from the child class.

If both the parent and child classes have methods with the same parameters, the overridden method in the child class will be called in this case as well.

This is essentially how method overriding works. Now we understand how to override a method and how it operates.

I hope this discussion has provided you with a preliminary understanding of the topics covered in this lesson. That’s all for today; we’ll see you in the next lesson.

You can connect with me on GitHub and Linkedin.

PHP OOP Part-5: Abstraction and Interface

Jamir Hossain — Thu, 02 Jan 2025 16:04:02 +0000

In this series, I will cover the fundamentals of PHP Object-Oriented Programming (OOP). The content will be organized into sequential parts, each focusing on a specific topic. If you're a beginner or unfamiliar with OOP concepts, this series is designed to guide you step by step. In this part, I will discuss about the abstraction and interface in PHP. Let's begin the journey of learning PHP OOP together!

What is Abstraction in PHP?

We know that in Object-Oriented Programming, Abstraction is an important concept. So, what is abstraction? Abstraction refers to hiding the implementation details of a program, showing only its functionalities.

Now, let's try to understand how abstraction works in PHP. First, we will look at a simple example where there will be a parent class, and one or more child classes will inherit from this parent class. After that, we will discuss the drawbacks of this approach.

Code Example

class Vehicle
{
   public function getBaseFare()
   {
      // implementation
   }

   public function getPerKiloFare()
   {
      // implementation
   }

   public function getTotalFare()
   {
      // implementation
   }
}


class Car extends Vehicle
{
   // Car implementation
}

class Bike extends Vehicle
{
   // Bike implementation
}

Here we can see that the Vehicle class is being inherited by the Car and Bike classes. As a result, both of these classes gain access to the methods present in the Vehicle class. However, there is a problem: the methods in the parent class come with their implementations, which the child classes inherit. This means that all the child classes will share a common implementation and behave the same way. But this shouldn't be the case because the behavior of a Car should be different from that of a Bike. However, since we inherited the methods from the parent class, both classes are behaving the same way.

Now, what can we do if, after inheriting these common methods, we want them to behave differently for each class?

To solve this problem, PHP provides the Abstract class. What is an Abstract class?

An Abstract class is a type of class that can have both abstract methods and non-abstract methods. So, what are abstract and non-abstract methods?

Abstract methods are methods that only have a definition but no implementation. As a result, when a child class inherits the parent class, it must provide an implementation for the abstract methods of the parent class.

Non-abstract methods are methods that have both a definition and an implementation in the parent class. The child class simply inherits these methods and can use them.

Now, we will try to solve the above problem using an Abstract class.

Code Example

abstract class Vehicle
{
   abstract public function getBaseFare();

   abstract public function getPerKiloFare();

   public function getTotalFare()
   {
      echo $this->getBaseFare() + $this->getPerKiloFare() . "\n";
   }
}


class Car extends Vehicle
{
   public function getBaseFare()
   {
      return 20;
   }

   public function getPerKiloFare()
   {
      return 10;
   }
}

class Bike extends Vehicle
{
   public function getBaseFare()
   {
      return 10;
   }

   public function getPerKiloFare()
   {
      return 5;
   }
}

$car = new Car();
$car->getTotalFare();

$bike = new Bike();
$bike->getTotalFare();

Here we can see that there is a class named Vehicle. If we want to make a class abstract, we need to use the abstract keyword before the class name. So, the Vehicle class is an abstract class. Similarly, if we want to make a method in an abstract class, we need to use the abstract keyword before the method name. It is important to note that if we want to make any member of a class abstract, that class must also be an abstract class.

Now, the abstract methods inherited from the Vehicle class have been implemented differently in each child class. As a result, these methods will behave differently and provide different results for each child class.

Now, we might wonder why we had to abstract the methods getBaseFare and getPerKiloFare in the parent class when we could have simply implemented them directly in the child classes.

If you pay close attention, you'll notice that in the parent class, the methods getBaseFare and getPerKiloFare are used within another method. But if we hadn't abstracted getBaseFare and getPerKiloFare and had only implemented them in the child classes, we would not have had access to them in the parent class. Therefore, methods that need to be accessed by both the parent and child classes, and whose behavior should be different in each child class, are abstracted.

It is important to note that an abstract class cannot be instantiated directly. Instead, it is accessed through the child class, and the abstract methods inherited from the abstract class must be implemented in the child class. If this is not done, nothing in the child class will work. I hope this gives you a better understanding of how to use abstract classes.

What is Interface in PHP?

In the previous discussion, we talked about abstract classes. From that, we learned that when inheriting abstract methods from an abstract class, those methods must be implemented in the child class; otherwise, nothing in the child class will work.

But what if, in a child class, one of the abstract methods is not needed, but it still has to be implemented? This wouldn't be a good solution. So, what can we do in this case?

In this situation, we can use interfaces. An interface is similar to an abstract class, but an abstract class is not fully abstract because, as we know, an abstract class can have both abstract and non-abstract members.

On the other hand, an interface can only have abstract members. As a result, an interface is considered a fully abstract class. Now, we will try to solve the above problem using an interface.

Code Example

interface HourlyRentable
{
   public function getHourlyRate();
}

abstract class Vehicle
{
   abstract public function getBaseFare();

   abstract public function getPerKiloFare();

   public function getTotalFare()
   {
      echo $this->getBaseFare() + $this->getPerKiloFare() . "\n";
   }
}


class Car extends Vehicle implements HourlyRentable
{
   public function getBaseFare()
   {
      return 20;
   }

   public function getPerKiloFare()
   {
      return 10;
   }

   public function  getHourlyRate()
   {
      echo "Hourly 2 Dollar";
   }
}

class Bike extends Vehicle
{
   public function getBaseFare()
   {
      return 10;
   }

   public function getPerKiloFare()
   {
      return 5;
   }
}

$car = new Car();
$car->getTotalFare();

$bike = new Bike();
$bike->getTotalFare();

Here in the interface, we see the declaration of the getHourlyRate function. Then, in the Car class, we use (implement or inherit) this interface and provide the implementation of the abstract method inside the interface. However, in the Bike class, we didn’t have to implement this method because we didn’t use (implement or inherit) the interface in the Bike class. But if this abstract method had been inside an abstract class, we would have been forced to implement this method in both child classes, even if it wasn’t needed, which would have resulted in a bad design. Additionally, interfaces have various other use cases.

I hope this episode has provided you with a basic understanding of the discussed topics. That’s all for today. We’ll talk again in the next lesson.

You can connect with me on GitHub and Linkedin.

PHP OOP Part-4: Static property, method and this vs self

Jamir Hossain — Thu, 02 Jan 2025 16:02:36 +0000

In this series, I will cover the fundamentals of PHP Object-Oriented Programming (OOP). The content will be organized into sequential parts, each focusing on a specific topic. If you're a beginner or unfamiliar with OOP concepts, this series is designed to guide you step by step. In this part, I will discuss about the static property, method and this vs self in PHP. Let's begin the journey of learning PHP OOP together!

What is property and method?

First, let us try to understand properties and methods. When we create multiple objects using a class, each object is allocated a separate memory location. As a result, all the properties and methods of that object are also allocated to that specific memory location.

This means that when we change any property of an object, the change is restricted to that particular object only. It does not affect any other objects because the properties and methods of a class are associated with the respective objects of that class.

To access these properties or methods from outside the class, we need to create an object of that class. However, if we want to access these properties or methods within the class, we can use the $this keyword. The $this keyword represents the current object of the class. We will learn more about the $this keyword later. Let us look at the following example:

Code Example

class Car
{
   public $name;
   public $color;

   function __construct(string $name, string $color)
   {
      $this->name  = $name;
      $this->color = $color;
   }

   public function getValue()
   {
      echo "Car name: $this->name\n";
      echo "Car color: $this->color\n";
   }
}

$tesla = new Car('Zip', 'Blue');
$tesla->getValue();

In this example, we can see that to access the properties of the class, we have used the $this keyword within the methods of the same class. Similarly, to use any method of this class from outside, we have created an object of the class. This is how we typically use the normal properties or methods of a class.

What is static property and method?

However, static properties or methods work differently. When we define a class, it is allocated a memory location only once. Similarly, when we define static properties or methods in a class, they are also allocated to a specific memory location alongside the class itself, but only once.

As a result, if we modify any static property or method later, the change will reflect across all instances of the class. In other words, wherever the static property or method is used, its updated value will be available.

If we want to access static properties or methods from outside the class, we can use the :: (scope resolution operator) without creating an object. Alternatively, we can also access them after creating an object. To access them from within the class, we can use the self keyword or the class name itself. Here, the self keyword represents the class.

We will explore the self keyword in more detail later. Let us look at the following example:

Code Example

class Car
{
   public static $name;
   public static $color;

   function __construct($name, $color)
   {
      self::$name = $name;
      self::$color = $color;
   }

   public static function getValue()
   {
      echo "Car name: " . self::$name . "\n";
      echo "Car color: " . self::$color . "\n";
   }
}

$toyota = new Car('Toyota', 'Black');
$bmw = new Car('BMW', 'Orange');

$toyota::getValue();
$bmw::getValue();

Car::getValue();

In this example, we can see that to access the static properties of the class, we have used the self keyword within the methods of the same class. Additionally, to use a static method from outside the class, we created an object of the class. However, we could also access it directly using the class name along with the :: (scope resolution operator), without creating an object. This is how we typically use the static properties or methods of a class.

In the above example, we can see that using the Car class, we created two objects, $toyota and $bmw, with different data. Now we want to access the values of these objects. If we run the code above, we will see the following output:

Code Example

Car name: BMW
Car color: Orange
Car name: BMW
Car color: Orange
Car name: BMW
Car color: Orange

We can see that both objects are showing the same values. In other words, the values we are getting are from the most recently created object. Even when we try to access the values directly through the class, we still get the same values, i.e., the values of the second object.

The reason for this is quite clear. As mentioned earlier, static properties or methods are created in a single memory location. If the static properties or methods are changed from anywhere, the change affects all instances of the class.

In the example above, when we created the second object, the values of the properties changed as soon as the object was created. This change also affected the previously created object because all objects of the class share the same static properties or methods.

It is important to remember that static properties or methods of a class cannot be used in the same way as normal class properties or methods. You cannot use the → operator to access them. Instead, you must use the ::(scope resolution operator), whether you are accessing them from inside or outside the class.

$this vs self Keyword

What is $this?

We have already seen the usage of the $this and self keywords. Now, let us delve deeper into these concepts to better understand them.

$this is a built-in PHP keyword. When we create one or more objects using a class, the normal properties and methods defined within the class can be accessed using the $this keyword from within the class.

Now, we know that when a class is defined, it is allocated to a specific memory location only once. This might raise a question: if we create multiple objects from this class, will the $this keyword access the properties or methods only once for all objects?

The answer is "No". This is because, as we have already discussed, the $this keyword does not represent the class itself but rather the object created by that class. In other words, $this is directly related to the object. As a result, for every object created, the $this keyword will access the properties and methods of the class separately for each object. Let us look at the following example:

class Car
{
   public $name;
   public $color;

   function __construct($name, $color)
   {
      $this->name = $name;
      $this->color = $color;
   }

   public function getValue()
   {
      echo "Car name: " . $this->name . "\n";
      echo "Car color: " . $this->color . "\n";
   }
}

In the previous example, we have used it multiple times, but the usage of $this was not discussed in detail. Now that we have gained some understanding of $this, we can better comprehend its usage. Using this class, we have created objects. Now, we understand that the $this keyword accesses the properties separately for each object.

However, it is important to note that the $this keyword cannot be used inside a static method. Why it cannot be used will be explained shortly.

What is the self keyword?

We already know that when a class is defined, it is allocated to a memory location only once. Similarly, all the static properties and methods within that class are also allocated to the memory location along with the class, only once.

As a result, when we create objects using this class, the static properties or methods are not separately created for each object. This is why we cannot access these static properties or methods using the $this keyword. The $this keyword represents the object of the class, and since static properties or methods are not related to any object but directly to the class itself, they cannot be accessed using $this.

To access static properties or methods within the class, we use the self keyword or the class name along with the ::(scope resolution operator). This is because the self keyword represents the class itself. Let us look at the following example:

class Car
{
   public $name;
   public static $color = "Red";

   function __construct($name)
   {
      $this->name = $name;
   }

   public function getValue()
   {
      echo "Car name: " . $this->name . "\n";
      echo "Car color: " . self::$color . "\n";
   }

   public static function getStaticValue()
   {
      $obj = new self("Toyota");
      echo "Car name: " . $obj->name . "\n";
      echo "Car color: " . self::$color . "\n";
   }
}

In this example, we see that we can easily access static members within a non-static method using the class name or the self keyword with the ::scope resolution operator, because they are related to the class. Therefore, to access them, we do not need to create a separate object.

However, if we want to access non-static members within a static method, we would need to use the $this keyword. But we know that the $this keyword cannot be used within a static method because $this is related to the object, while non-static members are not related to the object. This is the reason we cannot use the $this keyword within a static method.

However, if we need to access non-static members within a static method, we can create an instance or object of the class within the static method and then use the $this keyword to access them, as shown in the example above.

I hope this gives you a clearer understanding of the usage of $this and self keywords. That’s all for today; we’ll continue in the next lesson.

You can connect with me on GitHub and Linkedin.

PHP OOP Part-3: Access modifier, Encapsulation and Inheritance

Jamir Hossain — Thu, 02 Jan 2025 16:00:42 +0000

In this series, I will cover the fundamentals of PHP Object-Oriented Programming (OOP). The content will be organized into sequential parts, each focusing on a specific topic. If you're a beginner or unfamiliar with OOP concepts, this series is designed to guide you step by step. In this part, I will discuss about the access modifiers, encapsulation, and inheritance in PHP. Let's begin the journey of learning PHP OOP together!

What is Access Modifiers in PHP?

Access modifiers are used to control the access levels of class properties and methods. That is, it controls how much access you have, etc. PHP provides three types of access modifiers:

public: Accessible from anywhere.
protected: Accessible only within the class and its subclasses.
private: Accessible only within the class.

To use these access modifiers, you need to declare them using the keywords public, protected, or private before defining the properties or methods. It is important to note that if you do not specify any access modifier for a property or method, it is considered public by default.

Code Example

class MyClass {
    public $publicVar;      // Accessible from anywhere
    protected $protectedVar; // Accessible from this class and subclass
    private $privateVar;     // Accessible from only this class

    public function publicMethod() {
        // Accessible from anywhere
    }

    protected function protectedMethod() {
        // Accessible from this class and subclass
    }

    private function privateMethod() {
        // Accessible from only this class
    }
}

Using these access modifiers, we can control the access to a class's data and functionality, which is closely related to encapsulation and security within a class.

What is Encapsulation?

Encapsulation is the process of creating a new entity to ensure privacy or information security. A class can have various properties and methods, and we can use access modifiers to define how these properties and methods can be accessed outside the class. Simply put, encapsulation is about controlling access to class data and functionality.

Encapsulation can occur at different levels:

Property-Level Encapsulation

Properties are data members of a class that are associated with the class’s object. By default, properties are public, but we can secure them using private or protected access modifiers. This prevents direct access to the data from external code. This concept is known as Property-Level Encapsulation.

Method-Level Encapsulation

Methods are the functions or operations of a class that work on its instances. A method may contain many implementations that can be hidden from external classes. By doing this, we allow external code to use the method but not access its internal implementation. This is known as Method-Level Encapsulation.

Class-Level Encapsulation

At this level, the properties and methods of a class are securely stored within the class, and direct access to them from outside the class is restricted. They can, however, be accessed through inheritance. This is referred to as Class-Level Encapsulation.

Apart from these, encapsulation can be implemented at other levels as needed.

What is Inheritance?

Inheritance is a programming concept where a class (called a subclass or child class) inherits the properties and methods from another class (called a superclass or parent class).

To simplify, consider a class with certain properties and methods. If another class requires these same properties and methods, instead of rewriting them, in that time we can inherit them from the original class into the new class. This concept is referred to as inheritance, and its primary purpose is to reuse code and avoid code duplication. When a class inherits from another class:

The inheriting class is called the subclass or child class.
The inherited class is called the superclass or parent class.

Let’s look at an example of code

Code Example

class Vehicle
{
   public $name;
   public $color;

   public function start()
   {
      // start login
   }

   public function stop()
   {
      // stop login
   }
}

class Car extends Vehicle
{
   function __construct(string $name, string $color)
   {
      $this->name  = $name;
      $this->color = $color;
   }

   public function carInfo()
   {
      echo "Car name: $this->name\n";
      echo "Car color: $this->color\n";
   }
}

class Bus extends Vehicle
{
   function __construct(string $name, string $color)
   {
      $this->name  = $name;
      $this->color = $color;
   }

   public function busInfo()
   {
      echo "Bus name: $this->name\n";
      echo "Bus color: $this->color\n";
   }
}

$toyota = new Car('Toyota', 'Red');
$toyota->start();
$toyota->carInfo();
$toyota->stop();

$tesla = new Bus('Zip', 'Blue');
$tesla->start();
$tesla->busInfo();
$tesla->stop();

In the above example, we can see that the Vehicle class is inherited by both the Car and Bus classes. As a result, the properties and methods of the Vehicle class that are marked as public or protected can be accessed within these subclasses.

What is Multi-level Inheritance?

Multi-level Inheritance refers to a scenario where a class inherits from another class, and then that class itself is inherited by a third class. This allows the third class to access the properties and methods (marked as public or protected) of both the base and intermediate classes.

class Vehicle
{
   public $name;
   public $color;

   public function start()
   {
      // start login
   }

   public function stop()
   {
      // stop login
   }
}

class Car extends Vehicle
{
   function __construct(string $name, string $color)
   {
      $this->name  = $name;
      $this->color = $color;
   }

   public function carInfo()
   {
      echo "Car name: $this->name\n";
      echo "Car color: $this->color\n";
   }
}

class ElectricCar extends Car
{
   private $batteryCapacity;

   function __construct(string $name, string $color, int $batteryCapacity)
   {
      $this->name  = $name;
      $this->color = $color;
      $this->batteryCapacity = $batteryCapacity;
   }

   public function electricCarInfo()
   {
      echo "Electric Car name: $this->name\n";
      echo "Electric Car color: $this->color\n";
      echo "Battery Capacity: {$this->batteryCapacity} kWh\n";
   }
}

$teslaModelS = new ElectricCar('Tesla Model S', 'Black', 100);
$teslaModelS->start();
$teslaModelS->electricCarInfo();
$teslaModelS->stop();

In this example, the Vehicle class has been inherited by the Car class, and finally, the Car class has been inherited by the ElectricCar class. As a result, this demonstrates Multi-level Inheritance in action.

I hope this lesson has provided you with a fundamental understanding of the discussed topics. That’s all for today—see you in the next lesson! 😊

PHP OOP Part-2: Constructor and Destructor

Jamir Hossain — Mon, 02 Dec 2024 06:54:16 +0000

What is a Constructor?

Code Example

class Car
{
   public $name;
   public $color;

   public function setValue(string $name, string $color)
   {
      $this->name  = $name;
      $this->color = $color;
   }

   public function getValue()
   {
      echo "Car name: $this->name\n";
      echo "Car color: $this->color\n";
   }
}

$toyota = new Car;
$toyota->setValue('Toyota', 'Red');
$toyota->getValue();

Code Example

class Car
{
   public $name;
   public $color;

   function __construct(string $name, string $color)
   {
      $this->name  = $name;
      $this->color = $color;
   }

   public function getValue()
   {
      echo "Car name: $this->name\n";
      echo "Car color: $this->color\n";
   }
}

$toyota = new Car('Toyota', 'Red');
$toyota->getValue();

But now, the question arises: We didn’t call __construct(), so how did it receive the value and set it to the variable?

Code Example

new Car('Toyota', 'Red');

What is a Destructor?

Code Example

class Car
{
   public $name;
   public $color;

   function __construct(string $name, string $color)
   {
      $this->name  = $name;
      $this->color = $color;
   }

   public function getValue()
   {
      echo "Car name: $this->name\n";
      echo "Car color: $this->color\n";
   }

   function __destruct()
   {
      echo "I have called\n";
   }
}

$toyota = new Car('Toyota', 'Red');
$toyota->getValue();

$tesla = new Car('Zip', 'Blue');
$tesla->getValue();

If we run this code, we will see the following output.

Car name: Toyota
Car color: Red
Car name: Zip
Car color: Blue
I have called
I have called

So, that’s all for today. We’ll talk more about another topic in the next lesson. Stay tuned! Happy coding!

You can connect with me on Linkedin and GitHub.

PHP OOP Part-1: Introduction, Object, and Class

Jamir Hossain — Mon, 02 Dec 2024 06:12:27 +0000

In this series, I will cover the fundamentals of PHP Object-Oriented Programming (OOP). The content will be organized into sequential parts, each focusing on a specific topic. If you're a beginner or unfamiliar with OOP concepts, this series is designed to guide you step by step. In this part, I will discuss about the OOP introduction, object and class in PHP. Let's begin the journey of learning PHP OOP together!

Introduction

Imperative
Declarative
Procedural
Functional
Object-Oriented (OOP), etc.

However, in this series, we will focus on understanding the Object-Oriented Programming paradigm in PHP.

In this section, we will discuss the most important terms of Object-Oriented Programming System (OOP). We will try to understand each of these terms gradually.

What is an Object?

An object has various characteristics, such as:

Properties:
Properties of an object represent its attributes or features. For example, a car's properties could include its name, size, color, weight, etc.
Actions/Behaviors/Methods:
Actions, behaviors, or methods represent what an object can do. For instance, a car's behavior might include starting, stopping, or running.

Now for example, If we consider a Car object then we will find it's Properties and Behaviors.

Properties: color, size, weight, name, etc.
Behaviors: carCanStart(), carCanStop(), carCanRun(), etc.

Now the question is How to Create an Object in PHP? In PHP, to create an object, we first need to use a class. What is a class? We'll learn about that shortly. Meanwhile, consider the following example:

Code Example:

class Vehicle
{
   public $name;
   public $color;

   public function setValue(string $name, string $color)
   {
      $this->name  = $name;
      $this->color = $color;
   }

   public function getValue()
   {
      echo "Car name: $this->name\n";
      echo "Car color: $this->color\n";
   }
}

$toyota = new Vehicle;
$toyota->setValue('Toyota', 'Red');
$toyota->getValue();

What is a Class?

Code Example

class Car
{
   public $name;
   public $color;

   public function setValue(string $name, string $color)
   {
      $this->name  = $name;
      $this->color = $color;
   }

   public function getValue()
   {
      echo "Car name: $this->name\n";
      echo "Car color: $this->color\n";
   }
}

$toyota = new Car;
$toyota->setValue('Toyota', 'Red');
$toyota->getValue();

$tesla = new Car;
$tesla->setValue('Zip', 'Blue');
$tesla->getValue();

I hope you now have a basic understanding of the concepts discussed in this section. In the next lesson, we will continue to explore more about Object-Oriented Programming.

How PHP Works - Behind The Scene

Jamir Hossain — Tue, 12 Nov 2024 09:36:54 +0000

PHP (Hypertext Preprocessor) - Overview

PHP is a server-side scripting language initially developed by Rasmus Lerdorf in 1994 to manage his personal website. In 1995, PHP was released to the public, allowing web developers to create dynamic content more easily. PHP code runs on the server side, making it ideal for creating web applications that interact with databases, process user inputs, and deliver dynamic web pages.

Getting Started with PHP
What are Compiler and Interpreter?
What is an Interpreter, and How Does It Work?
What is a Compiler, and How Does It Work?
Is PHP a compiled or an interpreted language?
How JIT Compiler works in PHP?
Environments to run the PHP code
How does PHP code run through the CLI?
How does PHP code run through a web server?

Getting Started with PHP

Let's start with a simple example:

echo "Hello world";

If you run this code by terminal of your computer, then you will get the output "Hello world" in your terminal. We know that our computer only can understand the machine code like 0 or 1.

But how does your computer understand and run the code?
How does PHP code convert to a form that the computer can execute?

To understand this, let's look into how computers understand code. The computer only understands machine code, which is a binary format (0s and 1s). For high-level code like PHP to be executed, it needs to be translated to machine code. This is where compilers and interpreters come into play.

What are Compiler and Interpreter

Compiler and Interpreter are both translation software or programs that convert source code written in programming languages into machine code. That is, the code we write, which humans can understand, is converted by these compilers or interpreters into machine code (0s and 1s) that the computer can understand, allowing it to execute instructions and provide us with the output. Let’s dive for basic overview about these translators to understand them better.

What is an Interpreter, and How Does It Work

An Interpreter is a type of translator that reads the entire source code written in a high-level language line-by-line and immediately converts each line into machine code. If it encounters an error while reading a line of code, it stops immediately and reports the error to the programmer, making it easier to debug. This line-by-line execution also makes it a slower process compared to a compiler.

What is a Compiler, and How Does It Work

A Compiler is a type of translator that converts the entire source code written in a high-level language into machine code all at once. If there’s an error in the code, the compiler will still compile the entire code, but the error will be caught at runtime, making it harder for the programmer to identify and fix the error. However, since the compiler converts the entire source code to machine code at once, it generally performs faster than an interpreter during execution.

Is PHP a compiled or an interpreted language

So answer is that, PHP is primarily an interpreted language. When a PHP script is run, the PHP interpreter parses and executes the code at runtime, rather than compiling it to machine code beforehand, as with compiled languages like C or C++. However, some optimizations, like bytecode caching with tools such as OPcache, can improve performance by storing compiled bytecode to avoid reinterpreting the code on every request.

There are also projects like HHVM (HipHop Virtual Machine), which was developed by Facebook to execute PHP code using a Just-In-Time (JIT) compilation process. This allows it to compile PHP code into intermediate bytecode, then compile it to machine code on the fly, making PHP execution faster. With PHP 8, JIT compilation is integrated directly into PHP, allowing parts of the code to be compiled, further blurring the lines between interpreted and compiled behavior.

How JIT Compiler works in PHP

JIT, or Just-In-Time compilation, is a method of executing code by compiling parts of it "just in time" for execution, rather than ahead of time. Unlike traditional interpreted execution, which reads and executes code line by line, JIT compilation translates portions of the code into machine code right before they’re needed during runtime. This results in faster execution because the machine code runs directly on the CPU, avoiding the need for repeated interpretation.

JIT compilation sits between fully interpreted and fully compiled execution. Here’s how it works in general:

Initial Interpretation: The code is initially interpreted or run in a lightweight way to analyze which parts are most frequently used or computationally intensive.
On-the-fly Compilation: The JIT compiler identifies "hot spots"—code sections that are run often or require optimization. It then compiles these sections into machine code during runtime.
Execution: The compiled machine code is stored, so future executions can use the optimized version without recompiling it, speeding up performance.

In PHP, JIT was introduced in PHP 8, allowing frequently used functions or loops to run faster by compiling them into machine code as they’re executed. Other languages, like JavaScript (e.g., V8 engine in Chrome) and Java, also use JIT compilation for similar performance benefits.

Let's follow the below example.

In the first block, we have our written code. This code first goes into the JIT (Just-In-Time compiler). Then the JIT compiles and executes the code. During this execution, the JIT reads the code line by line and immediately converts each line into machine code after reading it. If there’s an error in any line during the reading process, it stops right there and throws that error.

So, this gives us a bit of an idea about how high-level PHP code (the code we write) is understood and run by the computer.

Environments to run the PHP code

PHP scripts can be run in two main environments: the Command Line Interface (CLI) and a web server environment.

Command Line Interface (CLI): PHP code can be executed directly from the command line on your computer. This allows developers to run scripts without a browser, often used for automation, cron jobs, or testing scripts.
Web Server Environment: PHP is commonly run within a web server environment, where the code is executed in response to requests from a client/browser. When a PHP script is requested, the web server communicates with the PHP engine through an interface layer (like CGI, FastCGI, or FPM), which processes the script and returns the output to the client.

Each environment serves different use cases, allowing PHP to be a flexible language for both web and command-line applications.

How does PHP code run through the CLI

Our computers contain various applications or programs that we run for different purposes. However, when we go to run these applications or programs, they cannot execute on their own. Instead, they run through the computer's operating system. When we write code in PHP, it also becomes a program that we can run through the computer's terminal. So, when we run our code through the terminal, it also executes via the operating system.

The question, then, is: how does this application or program, or the code we’ve written, communicate with our computer's operating system?

Let's follow the below example.

Here, the means used to communicate with the operating system is called the OS API (Operating System’s API). Through this OS API, applications or programs can communicate with the computer’s operating system, as shown in the diagram above. This gives us some understanding of how PHP code runs through the terminal on our computer.

How does PHP code run through a web server

First, from the client/browser, we send a request to the web server. However, the web server cannot communicate directly with the PHP engine. For communication between the web server and PHP engine, an intermediate layer works between them, known as SAPI or Server API. Different protocols are used as SAPIs, which allow the web server to communicate with the PHP engine. These protocols include CGI, FastCGI, mod_php, FPM, etc. Any one of these protocols can be used for communication between the web server and PHP engine.

Let's follow the below example.

The two most popular web servers for running PHP scripts are Apache and Nginx:

Apache Server uses the mod_php protocol as its SAPI.
Nginx Server uses the FPM protocol as its SAPI.

This gives us a better understanding of how PHP code runs on a web server. Based on the above points.

I hope got a basic idea of how PHP code actually works behind the scenes. If it is helpful, don't forget to share it with others.

Starting with C: All the Fundamentals in One Guide

Jamir Hossain — Sat, 09 Nov 2024 09:22:03 +0000

All the Fundamentals in One Guide of C Programming

"Starting with C: All the Fundamentals in One Guide" is your go-to resource for learning C programming from the ground up. This guide covers essential topics, from variables and data types to pointers and structure, providing a solid foundation for beginners. Whether you’re new to coding or brushing up on the basics, this comprehensive doc will equip you with the knowledge needed to start writing C programs confidently. Dive in and start your journey with C today!

This is also available on GitHub. Please leave a ⭐ on Github as motivation if this was helpful!

Format Specifiers
- Overview
- Integer Types
- Floating Point Types
- Character Types
- Other Specifiers
Data Types Overview
- Data Types
Input and Output
- Input Output
Operators
- Overview
- Arithmetic Operators
- Assignment Operators
- Relational Operators
- Logical Operators
Conditional
- Overview
- If Else
- Switch Case
Ternary Operators
- Ternary Operators
Loop
- Loop
- For Loop
- While Loop
- Do-While Loop
Array
- Overview
- How Arrays Work, Size of an Array
- Array Initialization
- Variable Length Arrays
String
- Overview
- String Input Output
- Finding Length of String
- Copy Strings
- Concatenating Two Strings
- Comparing Two Strings
Function
- Overview
- Declaring and Using Functions
- Function Parameters
- Function Return Value
- Function Scopes
Pointer
- Overview
- Working With Pointers
- Pointer Arithmetic
- Pointers and Constants
- Using Pointers to Pass by Address
- Null Pointers
Array and Pointers
- Overview
- Key Points
- Accessing Array Elements with Pointers
- Modifying Array Elements Using Pointers
- Passing Arrays to Functions Using Pointers
- Array and Pointer Key Note
Dynamic Memory Allocation
- Overview
- Dynamic Memory Management Functions
- Memory Allocation Key Note
Structure
- Overview
- Working with Structure
- Function and Structure
- Array of Structure
Next Steps
- Master Intermediate Concepts
- Start Small Projects
- Join Coding Challenges
Resources
- Tutorials
- Books
- Online Courses
- Practice Platforms
- Documentation and Reference

Format Specifiers

In the context of printf and scanf, format specifiers (or modifiers) are used to indicate the type of data being read or printed. Here's a breakdown of the common format specifiers used with printf and scanf for various data types and their modifiers:

Integer Types

%d: Used for int. Reads or prints a signed integer.
%u: Used for unsigned int. Reads or prints an unsigned integer.
%hd: Used for short int. Reads or prints a signed short integer.
%hu: Used for unsigned short int. Reads or prints an unsigned short integer.
%ld: Used for long int. Reads or prints a signed long integer.
%lu: Used for unsigned long int. Reads or prints an unsigned long integer.
%lld: Used for long long int. Reads or prints a signed long long integer.
%llu: Used for unsigned long long int. Reads or prints an unsigned long long integer.

Floating-Point Types

%f: Used for float. Reads or prints a floating-point number.
%lf: Used for double. Reads or prints a double-precision floating-point number.
%Lf: Used for long double. Reads or prints an extended precision floating-point number.

Character Types

%c: Used for char. Reads or prints a single character.
%s: Used for char[] (string). Reads or prints a string of characters.

Other Specifiers

%p: Used for pointers. Prints a pointer address.
%%: Prints a literal % character.

Example Usage:

#include <stdio.h>

int main()
{
   int a;
   unsigned int b;
   float c;
   double d;
   char e;
   char str[100];

   // Reading input
   printf("Enter an integer: ");
   scanf("%d", &a);

   printf("Enter an unsigned integer: ");
   scanf("%u", &b);

   printf("Enter a float: ");
   scanf("%f", &c);

   printf("Enter a double: ");
   scanf("%lf", &d);

   printf("Enter a character: ");
   scanf(" %c", &e); // Note the space before %c to consume any leftover newline

   printf("Enter a string: ");
   scanf("%s", str);

   // Printing output
   printf("Integer: %d\n", a);
   printf("Unsigned Integer: %u\n", b);
   printf("Float: %.2f\n", c);
   printf("Double: %.2lf\n", d);
   printf("Character: %c\n", e);
   printf("String: %s\n", str);

   return 0;
}

Data Types Overview

This program demonstrates various data types in C, including their sizes and ranges.

1. Integer (`int`)

Size: 4 bytes
Range: -2,147,483,648 to 2,147,483,647

2. Floating-point (`float`)

Size: 4 bytes
Range: Approximately 1.2E-38 to 3.4E+38

3. Double (`double`)

Size: 8 bytes
Range: Approximately 2.2E-308 to 1.8E+308

4. Character (`char`)

Size: 1 byte
Range: -128 to 127 (ASCII values)

5. Boolean (using `int`)

Size: 4 bytes
Range: 0 (false) or 1 (true)

6. Short Integer (`short`)

Size: 2 bytes
Range: -32,768 to 32,767

7. Long Integer (`long`)

Size: 8 bytes (on most platforms, depending on the compiler and system architecture)
Range: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

8. Unsigned Integer (`unsigned int`)

Size: 4 bytes
Range: 0 to 4,294,967,295

Code Example:

#include <stdio.h>
#include <limits.h>
#include <float.h>

int main()
{
   // Integer data type
   int integerVar = 42;
   printf("Integer: %d\n", integerVar);

   // Floating-point data type
   float floatVar = 3.14f;
   printf("Float: %.2f\n", floatVar);

   // Double data type
   double doubleVar = 2.718281828459;
   printf("Double: %.12lf\n", doubleVar);

   // Character data type
   char charVar = 'A';
   printf("Character: %c\n", charVar);

   // Boolean data type (using int)
   int boolVar = 1; // 1 for true, 0 for false
   printf("Boolean (as int): %d\n", boolVar);

   // Short integer data type
   short shortVar = 32767;
   printf("Short: %d\n", shortVar);

   // Long integer data type
   long longVar = 1234567890L;
   printf("Long: %ld\n", longVar);

   // Unsigned integer data type
   unsigned int unsignedVar = 4000000000U;
   printf("Unsigned Integer: %u\n", unsignedVar);

   return 0;
}

Input and Output

In C, there are several functions for handling input and output, primarily in the <stdio.h> library:

fgets:
- Used to read a string that includes spaces, which allows the user to enter their full name. The function reads a line of text and stores it in the name array.
- Example usage: fgets(name, sizeof(name), stdin);
scanf:
- Used to read integer and float inputs for age and height, which are then stored in their respective variables.
- Example usage: scanf("%d", &age); and scanf("%f", &height);
printf:
- Used to display formatted output back to the user, including:
- The user's name with %s
- The user's age with %d
- The user's height with %.2f, which limits the height output to two decimal places for clarity.

Code Example:

#include <stdio.h>

int main()
{
   int age;
   float height;
   char name[50];

   // Asking for user input
   printf("Enter your name: ");
   fgets(name, sizeof(name), stdin); // reads a line of text
   printf("Enter your age: ");
   scanf("%d", &age);
   printf("Enter your height in meters (e.g., 1.75): ");
   scanf("%f", &height);

   // Displaying output
   printf("\nHello, %s", name); // fgets includes newline, so no need to add \n here
   printf("You are %d years old and %.2f meters tall.\n", age, height);

   return 0;
}

Operators

Arithmetic Operators

Arithmetic operators are used to perform basic mathematical operations such as addition, subtraction, multiplication, division, and modulus.

Addition (+): Adds two numbers.
Subtraction (-): Subtracts the second number from the first.
Multiplication (*): Multiplies two numbers.
Division (/): Divides the first number by the second, producing a quotient.
Modulus (%): Finds the remainder when the first number is divided by the second (applicable to integers).

Code Example:

#include <stdio.h>

int main()
{
   int num1, num2;

   // Prompt the user to enter two integers
   printf("Enter two integers: ");
   scanf("%d %d", &num1, &num2);

   // Perform arithmetic operations
   int sum = num1 + num2;        // Addition
   int difference = num1 - num2; // Subtraction
   int product = num1 * num2;    // Multiplication
   int quotient = num1 / num2;   // Division
   int remainder = num1 % num2;  // Modulus

   // Display the results
   printf("%d + %d = %d\n", num1, num2, sum);
   printf("%d - %d = %d\n", num1, num2, difference);
   printf("%d * %d = %d\n", num1, num2, product);
   printf("%d / %d = %d\n", num1, num2, quotient);
   printf("%d %% %d = %d\n", num1, num2, remainder);

   return 0;
}

Assignment Operators

Assignment operators allow values to be assigned and modified in a single statement.

= : Assigns the value on the right to the variable on the left.
+= : Adds the right operand to the left operand and assigns the result to the left operand.
-= : Subtracts the right operand from the left operand and assigns the result to the left operand.
*= : Multiplies the left operand by the right operand and assigns the result to the left operand.
/= : Divides the left operand by the right operand and assigns the result to the left operand.
%= : Takes the modulus of the left operand by the right operand and assigns the result to the left operand.

Code Example:

#include <stdio.h>

int main()
{
   int num1, num2;

   // Prompt the user to enter two integers
   printf("Enter two integers: ");
   scanf("%d %d", &num1, &num2);

   // Basic assignment
   int result = num1;
   printf("Initial result: %d\n", result);

   // Compound assignment operators

   // Equivalent to result = result + num2
   result += num2;
   printf("After += : %d\n", result);

   // Equivalent to result = result - num2
   result -= num2;
   printf("After -= : %d\n", result);

   // Equivalent to result = result * num2
   result *= num2;
   printf("After *= : %d\n", result);

   // Equivalent to result = result / num2
   result /= num2;
   printf("After /= : %d\n", result);

   // Equivalent to result = result % num2
   result %= num2;
   printf("After %%= : %d\n", result);

   return 0;
}

Relational Operators

Relational operators are used to compare two values and return a boolean result (represented as 1 for true and 0 for false in C).

Code Example:

#include <stdio.h>

int main()
{
    int num1, num2;
    printf("Enter two integers: ");
    scanf("%d %d", &num1, &num2);

    // Relational operations
    int isEqual = (num1 == num2);
    int isNotEqual = (num1 != num2);
    int isGreater = (num1 > num2);
    int isLess = (num1 < num2);
    int isGreaterOrEqual = (num1 >= num2);
    int isLessOrEqual = (num1 <= num2);

    // Printing results
    printf("%d == %d: %d\n", num1, num2, isEqual);
    printf("%d != %d: %d\n", num1, num2, isNotEqual);
    printf("%d > %d: %d\n", num1, num2, isGreater);
    printf("%d < %d: %d\n", num1, num2, isLess);
    printf("%d >= %d: %d\n", num1, num2, isGreaterOrEqual);
    printf("%d <= %d: %d\n", num1, num2, isLessOrEqual);

    return 0;
}

Logical Operators

Logical operators are used to combine or invert boolean expressions, allowing for complex conditions in decision-making processes.

Code Example:

#include <stdio.h>

int main()
{
   int num1, num2;
   printf("Enter two integers: ");
   scanf("%d %d", &num1, &num2);

   int isEqual = (num1 == num2);
   int isGreater = (num1 > num2);

   // Logical operations
   int bothTrue = isEqual && isGreater;   // Logical AND
   int eitherTrue = isEqual || isGreater; // Logical OR
   int notEqual = !isEqual;               // Logical NOT

   // Printing results
   printf("(%d == %d) && (%d > %d): %d\n", num1, num2, num1, num2, bothTrue);
   printf("(%d == %d) || (%d > %d): %d\n", num1, num2, num1, num2, eitherTrue);
   printf("!(%d == %d): %d\n", num1, num2, notEqual);

   return 0;
}

Conditional

Conditional statements to execute different blocks of code based on specified conditions. These conditions can be evaluated using various constructs, such as if, else if, else, switch, and the ternary operator. Conditional programs allow for decision-making within the code, enabling different outcomes based on user input or variable values.

If-Else

A conditional structure that executes different code blocks based on whether a condition is true or false.
Use when evaluating multiple conditions that may involve complex logical expressions or ranges.

Code Example:

#include <stdio.h>

int main()
{
   int num1, num2;
   printf("Enter two integers: ");
   scanf("%d %d", &num1, &num2);

   // Using if-else to compare numbers
   if (num1 > num2)
   {
      printf("%d is greater than %d\n", num1, num2);
   }
   else if (num1 < num2)
   {
      printf("%d is less than %d\n", num1, num2);
   }
   else
   {
      printf("%d is equal to %d\n", num1, num2);
   }

   return 0;
}

Switch-Case

A control structure that executes different code blocks based on the specific value of a variable or expression.
Use when dealing with a single variable that can take on multiple discrete values, making the code more readable for menu selections or similar scenarios.

Code Example:

#include <stdio.h>

int main()
{
   int num1, num2;
   printf("Enter two integers: ");
   scanf("%d %d", &num1, &num2);

   int choice;
   printf("Choose an operation:\n");
   printf("1. Add\n");
   printf("2. Subtract\n");
   printf("3. Multiply\n");
   printf("4. Divide\n");
   printf("Enter your choice (1-4): ");
   scanf("%d", &choice);

   // Using switch to perform operations based on user choice
   switch (choice)
   {
   case 1:
      printf("Result: %d + %d = %d\n", num1, num2, num1 + num2);
      break;
   case 2:
      printf("Result: %d - %d = %d\n", num1, num2, num1 - num2);
      break;
   case 3:
      printf("Result: %d * %d = %d\n", num1, num2, num1 * num2);
      break;
   case 4:
      if (num2 != 0)
      {
         printf("Result: %d / %d = %.2f\n", num1, num2, (float)num1 / num2);
      }
      else
      {
         printf("Error: Division by zero is not allowed.\n");
      }
      break;
   default:
      printf("Invalid choice.\n");
      break;
   }

   return 0;
}

Ternary Operators

The ternary operator is a shorthand conditional operator that evaluates a boolean expression and returns one of two values based on whether the expression is true or false. It utilizes the ternary operator, a shorthand for if-else, to evaluate and assign the maximum and minimum values.

Code Example:

#include <stdio.h>

int main()
{
   int num1, num2;
   printf("Enter two integers: ");
   scanf("%d %d", &num1, &num2);

   // Using the ternary operator to find the larger number
   int max = (num1 > num2) ? num1 : num2;

   // Using the ternary operator to find the smaller number
   int min = (num1 < num2) ? num1 : num2;

   printf("The larger number is: %d\n", max);
   printf("The smaller number is: %d\n", min);

   return 0;
}

Loop

A loop in programming is a control structure that allows a block of code to be executed repeatedly based on a specified condition. Loops facilitate the automation of repetitive tasks by iterating through a sequence of instructions until a particular condition is met. Common types of loops include for, while, and do-while, each serving different use cases based on the nature of iteration required.

For Loop

The for loop is used when the number of iterations is known beforehand. It consists of three parts: initialization, condition, and increment/decrement.

Code Example:

#include <stdio.h>

int main()
{
   // Use a for loop for a known number of iterations.
   printf("Using for loop:\n");

   for (int i = 1; i <= 10; i++)
   {
      printf("%d ", i);
   }

   printf("\n");

   return 0;
}

While Loop

The while loop is used when the number of iterations is not known and should continue until a specific condition is met. The loop checks the condition before executing the body.

Code Example:

#include <stdio.h>

int main()
{
   // Use a while loop when the loop should continue until a condition changes.
   printf("Using while loop:\n");
   int j = 1;

   while (j <= 10)
   {
      printf("%d ", j);
      j++;
   }

   printf("\n");

   return 0;
}

Do-While Loop

The do-while loop guarantees that the loop body is executed at least once, as the condition is checked after the execution of the loop body.

Code Example:

#include <stdio.h>

int main()
{
   // Use a do-while loop when you need to execute the loop body at least once before checking the condition.
   printf("Using do-while loop:\n");
   int k = 1;

   do
   {
      printf("%d ", k);
      k++;
   } while (k <= 10);

   printf("\n");

   return 0;
}

Array

An array is a collection of elements, all of the same data type, stored in contiguous memory locations. Arrays allow efficient storage and access of multiple values using a single variable name, accessed via indexing.

Code Example

int numbers[5] = {85, 90, 78, 92, 88}; // Declares an array of 5 integers

How Arrays Work, Size of an Array

Arrays use contiguous memory blocks, where each element can be accessed with an index starting at 0. The total size of an array depends on the data type and the number of elements it contains. For example, an int array with 5 elements requires 5 * sizeof(int) bytes.

Code Example:

#include <stdio.h>

int main() {
    int numbers[5] = {1, 2, 3, 4, 5};

    printf("Size of the array: %lu bytes\n", sizeof(numbers));
    printf("Number of elements: %lu\n", sizeof(numbers) / sizeof(numbers[0]));

    return 0;
}

Array Initialization

An array can be initialized at the time of declaration, where values are assigned to the array elements directly. If the array size is specified, but fewer elements are provided, the remaining elements are initialized to 0.

Code Example:

#include <stdio.h>

int main() {
   int ages[5] = {18, 21, 25}; // Remaining elements are initialized to 0
   for (int i = 0; i < 5; i++) {
      printf("%d ", ages[i]); // Output: 18 21 25 0 0
   }

    return 0;
}

Variable Length Arrays

Variable Length Arrays (VLAs) allow the size of the array to be determined at runtime instead of compile-time. This flexibility is useful when the number of elements is only known during execution.

Code Example:

#include <stdio.h>

int main() {
    int n;
    printf("Enter the number of elements: ");
    scanf("%d", &n);

    int values[n]; // VLA declaration
    for (int i = 0; i < n; i++) {
        values[i] = i * 2;
    }

    for (int i = 0; i < n; i++) {
        printf("%d ", values[i]);
    }

    return 0;
}

String

A string in C is a sequence of characters terminated by a null character ('\0'). Strings are stored as arrays of characters, where the last character is always '\0' to indicate the end of the string.

Code Example

char greeting[6] = "Hello"; // Declares a string with 5 characters and a null terminator
printf("Name: %s\n", greeting);

String Input Output

To handle string input and output, we commonly use scanf and printf. However, scanf stops reading at whitespace, so fgets is often preferred for input to allow spaces within strings.

Code Example:

#include <stdio.h>

int main() {
    char name[50];

    printf("Enter your name: ");
    fgets(name, sizeof(name), stdin); // Reads a line of text including spaces
    printf("Hello, %s", name);        // Outputs the entered name

    return 0;
}

Finding Length of String

The strlen function, available in <string.h>, is used to find the length of a string. It counts characters until the null terminator, excluding it.

Code Example:

#include <stdio.h>
#include <string.h>

int main() {
    char word[100] = "Programming";
    int length = strlen(word);

    printf("Length of the string: %d\n", length); // Output: 11

    return 0;
}

Copy Strings

The strcpy function, available in <string.h>, copies a source string to a destination string, including the null terminator. Ensure the destination has enough space to avoid overflow.

Code Example:

#include <stdio.h>
#include <string.h>

int main() {
    char source[] = "Hello";
    char destination[20];

    strcpy(destination, source);
    printf("Copied string: %s\n", destination); // Output: Hello

    return 0;
}

Concatenating Two Strings

The strcat function, found in <string.h>, appends the contents of one string to the end of another. Make sure the destination has enough space to hold both strings.

Code Example:

#include <stdio.h>
#include <string.h>

int main() {
    char first[20] = "Hello, ";
    char second[] = "World!";

    strcat(first, second);
    printf("Concatenated string: %s\n", first); // Output: Hello, World!

    return 0;
}

Comparing Two Strings

The strcmp function, provided by <string.h>, compares two strings lexicographically. It returns 0 if the strings are equal, a negative value if the first is less, and a positive value if the first is greater.

Code Example:

#include <stdio.h>
#include <string.h>

int main() {
    char str1[] = "apple";
    char str2[] = "banana";
    int result = strcmp(str1, str2);

    if (result == 0) {
        printf("Strings are equal\n");
    } else if (result < 0) {
        printf("str1 is less than str2\n");
    } else {
        printf("str1 is greater than str2\n");
    }

    return 0;
}

Function

Function in C are reusable blocks of code designed to perform a specific task. They help in organizing code, reducing repetition, and making programs easier to read and maintain. Each function can be called multiple times within a program, which allows for efficient code reuse.

Declaring and Using Functions

Function in C need to be declared before they are used. A function declaration includes the function's return type, name, and parameters. The function definition provides the actual code to execute when the function is called.

Code Example:

#include <stdio.h>

// Function declaration
void greet();

// Function definition
void greet() {
    printf("Hello from the greet function!\n");
}

int main() {
    // Calling the function
    greet();

    return 0;
}

Function Parameters

Function parameters (or arguments) allow data to be passed to a function. Parameters are specified within the parentheses in the function declaration and definition. When calling the function, you provide values (arguments) for these parameters.

Code Example:

#include <stdio.h>

// 'number' is a parameter
void displayNumber(int number) {
    printf("The number is: %d\n", number);
}

int main() {
    // Calling the function with argument 5
    displayNumber(5);

    return 0;
}

Function Return Value

A function can return a value using the return statement. The return type of the function (like int, float, etc.) must match the type of value it returns. If a function doesn’t return a value, its return type is void.

Code Example:

#include <stdio.h>

// Function with return type 'int'
int add(int a, int b) {
    return a + b;
}

int main() {
    // Calling the function and storing the return value
    int sum = add(3, 4);

    printf("Sum: %d\n", sum);

    return 0;
}

Function Scopes

The scope of a variable defines where it can be accessed within a program. Variables declared inside a function are local to that function and can’t be accessed outside it. Global variables, declared outside of any function, are accessible throughout the program.

Code Example:

#include <stdio.h>

int globalVar = 10; // Global variable

void display() {
    int localVar = 20; // Local variable
    printf("Global variable: %d\n", globalVar);
    printf("Local variable: %d\n", localVar);
}

int main() {
    // Can access both global and local variables in display function
    display();

    // Error: It wll show an error as localVar is not accessible here
    printf("%d", localVar);

    return 0;
}

Pointer

A pointer is a variable that stores the memory address of another variable. Pointers allow direct access to memory and enable efficient manipulation of data by working with memory locations rather than copying data values. Pointers are essential for dynamic memory management in C.

Code Example:

#include <stdio.h>

int main() {
    int num = 10;
    int *ptr = &num; // 'ptr' is a pointer to 'num'

    printf("Value of num: %d\n", num);
    printf("Address of num: %p\n", ptr); // prints the address stored in ptr
    printf("Value at address stored in ptr: %d\n", *ptr); // dereferencing pointer

    return 0;
}

Working With Pointers

Working with pointers involves using the & operator to get the address of a variable and the * operator (dereference operator) to access the value stored at the address held by the pointer.

Code Example:

#include <stdio.h>

void updateValue(int *ptr) {
    *ptr = 20; // modifies the value at the address stored in ptr
}

int main() {
    int num = 10;
    updateValue(&num); // passing the address of num
    printf("Updated value of num: %d\n", num);

    return 0;
}

Pointer Arithmetic

Pointer arithmetic allows manipulation of pointers to navigate through arrays or memory. Incrementing a pointer (ptr + 1) moves it to the next element based on the data type size.

Code Example:

#include <stdio.h>

int main() {
    int arr[] = {10, 20, 30, 40};
    int *ptr = arr; // points to the first element

    for (int i = 0; i < 4; i++) {
        printf("Value at arr[%d]: %d\n", i, *ptr);
        ptr++; // moves to the next element in the array
    }

    return 0;
}

Pointers and Constants

Pointers can be declared as pointing to constant values or as constant pointers. This restricts modification either to the value being pointed to or the pointer itself.

Pointer to Constant: const int *ptr means the pointer cannot change the value it points to.
Constant Pointer: int *const ptr means the pointer cannot point to another address.

Code Example:

#include <stdio.h>

int main() {
    int num1 = 10, num2 = 20;
    const int *ptr1 = &num1; // Pointer to constant
    int *const ptr2 = &num1; // Constant pointer

    // *ptr1 = 15; // Error: cannot modify the value
    ptr1 = &num2;  // Allowed: can change the address

    *ptr2 = 15;    // Allowed: can modify the value
    // ptr2 = &num2; // Error: cannot change the address

    return 0;
}

Using Pointers to Pass by Address

Passing variables by address to a function enables the function to modify the actual value of the variable in the calling environment. This is useful when a function needs to return multiple values or modify a large data structure.

Code Example:

#include <stdio.h>

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 5, y = 10;
    swap(&x, &y); // passing addresses of x and y
    printf("Swapped values: x = %d, y = %d\n", x, y);

    return 0;
}

Null Pointers

A null pointer is a pointer that points to nothing (address 0). It is useful for indicating that the pointer is not currently pointing to any valid memory location.

Code Example:

#include <stdio.h>

int main() {
    int *ptr = NULL; // null pointer

    if (ptr == NULL) {
        printf("Pointer is null, not pointing to any memory address.\n");
    } else {
        printf("Pointer value: %d\n", *ptr);
    }

    return 0;
}

Array and Pointer

In C, arrays and pointer are closely related. When an array is declared, its name represents the address of the first element, making it functionally similar to a pointer. However, arrays are not the same as pointers. Arrays have a fixed size and their names cannot be reassigned to point to different memory locations, while pointers are variables that can store any address.

Key Points

The name of an array is essentially a constant pointer to its first element.
Accessing an array element (arr[i]) is equivalent to pointer arithmetic (*(arr + i)).
Although arrays and pointers are related, they are distinct: an array name is a constant pointer, while a pointer variable can be reassigned.

Accessing Array Elements with Pointers

Using pointer arithmetic, you can access array elements by incrementing a pointer instead of using traditional array indexing.

Code Example

#include <stdio.h>

int main()
{
    int arr[5] = {10, 20, 30, 40, 50};

    // Access the first element pointer of array
    printf("First Element %p\n", arr);

    // Accessing elements using pointer arithmetic
    for (int i = 0; i < 5; i++)
    {
        printf("Element %d: %d\n", i, *(arr + i));
    }

    // Accessing elements using array index
    for (int i = 0; i < 5; i++)
    {
        printf("Element %d: %d\n", i, arr[i]);
    }

    return 0;
}

Modifying Array Elements Using Pointers

You can use pointers to modify elements within an array. By dereferencing the pointer, you directly access and modify each element in the array.

Code Example:

#include <stdio.h>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int *ptr = arr; // Pointer to the first element of the array

    // Modifying elements using pointer arithmetic
    for (int i = 0; i < 5; i++) {
        *(ptr + i) += 10; // Adds 10 to each element
    }

    // Displaying modified array
    for (int i = 0; i < 5; i++) {
        printf("Modified Element %d: %d\n", i, arr[i]);
    }

    return 0;
}

Passing Arrays to Functions Using Pointers

When you pass an array to a function, you are actually passing a pointer to the first element of the array. This allows the function to modify the original array elements directly.

Code Example:

#include <stdio.h>

// Function to increment each element by a given value
void incrementArray(int *arr, int size, int increment) {
    for (int i = 0; i < size; i++) {
        *(arr + i) += increment; // Modify each element
    }
}

int main() {
    int arr[] = {5, 10, 15, 20, 25};
    int size = sizeof(arr) / sizeof(arr[0]);

    incrementArray(arr, size, 5); // Pass array to function

    // Displaying the modified array
    for (int i = 0; i < size; i++) {
        printf("Element %d after increment: %d\n", i, arr[i]);
    }

    return 0;
}

Array and Pointer Key Note

Array Name as Pointer: The array name represents a pointer to the first element, enabling pointer-style access.
Pointer Arithmetic: Pointer arithmetic allows easy navigation and manipulation of array elements.
Passing Arrays: Arrays can be passed to functions as pointers, allowing direct modification of the original array.

Dynamic Memory Allocation

Dynamic memory allocation in C is a process of allocating memory at runtime, as opposed to compile-time. This is useful when the exact size of memory needed is unknown at the time of writing the program. Dynamic memory allocation is managed using pointers, and four key functions are provided by the C standard library for this purpose:

malloc: Allocates a specified number of bytes and returns a pointer to the allocated memory.
calloc: Allocates memory for an array of elements, initializes them to zero, and returns a pointer.
realloc: Resizes previously allocated memory to a new size.
free: Deallocates memory that was previously allocated.

Dynamic Memory Management Functions

1. `malloc`

Stands for "memory allocation".
Allocates a specified amount of memory (in bytes) but does not initialize it.
Returns a pointer to the beginning of the allocated memory block.

Example

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr;
    int n = 5;

    // Allocating memory for 5 integers
    ptr = (int *)malloc(n * sizeof(int));

    if (ptr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

    // Initializing and displaying allocated memory
    for (int i = 0; i < n; i++) {
        ptr[i] = i + 1;
        printf("ptr[%d] = %d\n", i, ptr[i]);
    }

    // Freeing the allocated memory
    free(ptr);
    return 0;
}

1. `malloc`

Stands for "memory allocation".
Allocates a specified amount of memory (in bytes) but does not initialize it.
Returns a pointer to the beginning of the allocated memory block.

Code Example:

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int *ptr;
    int n = 5;

    // Allocating memory for 5 integers
    ptr = (int *)calloc(n, sizeof(int));

    if (ptr == NULL)
    {
        printf("Memory allocation failed\n");
        return 1;
    }

    // Displaying initialized memory (all elements are zero)
    for (int i = 0; i < n; i++)
    {
        printf("ptr[%d] = %d\n", i, ptr[i]);
    }

    // Freeing the allocated memory
    free(ptr);
    return 0;
}

2. `calloc`

Stands for "contiguous allocation".
Allocates memory for an array of elements, initializes all bytes to zero.
Takes two parameters: the number of elements and the size of each element.

Code Example:

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr;
    int n = 5;

    // Allocating memory for 5 integers
    ptr = (int *)calloc(n, sizeof(int));

    if (ptr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

    // Displaying initialized memory (all elements are zero)
    for (int i = 0; i < n; i++) {
        printf("ptr[%d] = %d\n", i, ptr[i]);
    }

    // Freeing the allocated memory
    free(ptr);
    return 0;
}

3. `realloc`

Stands for "re-allocation".
Changes the size of previously allocated memory without losing its content.
Useful when the initial memory size needs adjustment.

Code Example:

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr;
    int n = 5;

    // Allocating memory for 5 integers
    ptr = (int *)malloc(n * sizeof(int));

    if (ptr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

    // Initializing allocated memory
    for (int i = 0; i < n; i++) {
        ptr[i] = i + 1;
    }

    // Reallocating memory to store 10 integers
    n = 10;
    ptr = (int *)realloc(ptr, n * sizeof(int));

    if (ptr == NULL) {
        printf("Memory reallocation failed\n");
        return 1;
    }

    // Initializing the newly allocated memory
    for (int i = 5; i < n; i++) {
        ptr[i] = i + 1;
    }

    // Displaying all elements
    for (int i = 0; i < n; i++) {
        printf("ptr[%d] = %d\n", i, ptr[i]);
    }

    // Freeing the allocated memory
    free(ptr);
    return 0;
}

4. `free`

Used to release memory that was previously allocated using malloc, calloc, or realloc.
Failing to free memory may cause memory leaks, which can degrade performance over time.

Code Example:

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr;

    // Allocating memory for 5 integers
    ptr = (int *)malloc(5 * sizeof(int));

    if (ptr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

    // Freeing the allocated memory
    free(ptr);
    printf("Memory has been freed.\n");

    return 0;
}

Memory Allocation Key Note

Function	Purpose	Initialization	Usage
`malloc`	Allocates memory	No	Used for allocating a specific number of bytes
`calloc`	Allocates memory for an array	Yes (zero-initialized)	Useful for allocating memory for arrays
`realloc`	Changes size of allocated memory	No	Expands or contracts previously allocated memory
`free`	Deallocates memory	-	Releases memory back to the system

Structure

Structure in C allow you to group different data types under a single name, making it easier to manage related data as a unit. They are particularly useful for representing complex data records, such as a student’s name, age, and grades.

Declaration, Initialization, and Assignment

To use a structure, first declare it with struct keyword and the name of a structure. Then, you can initialize a structure variable and assign values to its members.

Code Example:

#include <stdio.h>

struct Student {
    char name[50];
    int age;
    float grade;
};

int main() {
    struct Student student1 = {"Alice", 20, 85.5};  // Initialization
    student1.age = 21;  // Assignment

    printf("Name: %s, Age: %d, Grade: %.2f\n", student1.name, student1.age, student1.grade);

    return 0;
}

Working with Structure

You can access members of a structure using the dot . operator. Structures can also be used in arrays or passed to functions, making them versatile tools for managing data.

Code Example:

#include <stdio.h>

struct Student {
    char name[50];
    int age;
    float grade;
};

int main() {
    struct Student student1;

    printf("Enter name: ");
    scanf("%s", student1.name);

    printf("Enter age: ");
    scanf("%d", &student1.age);

    printf("Enter grade: ");
    scanf("%f", &student1.grade);

    printf("Student - Name: %s, Age: %d, Grade: %.2f\n", student1.name, student1.age, student1.grade);

    return 0;
}

Function and Structure

You can pass structures to functions by value or by reference (using pointers). Passing by reference is more memory-efficient, especially for large structures.

Code Example:

#include <stdio.h>

struct Student
{
   char name[50];
   int age;
   float grade;
};

// Function to display student information
void displayStudent(struct Student *s)
{
   printf("Name: %s, Age: %d, Grade: %.2f\n", s->name, s->age, s->grade);

   strcpy(s->name, "Jamir");
}

int main()
{
   struct Student student1 = {"Bob", 22, 90.0};
   displayStudent(&student1);

   printf("Name: %s, Age: %d, Grade: %.2f\n", student1.name, student1.age, student1.grade);

   return 0;
}

Array of Structure

An array of structure allows you to store multiple records of the same structure type, which is useful for handling collections of data like a list of students.

Code Example:

#include <stdio.h>

struct Student {
    char name[50];
    int age;
    float grade;
};

int main() {
    struct Student students[3] = {
        {"Alice", 20, 85.5},
        {"Bob", 21, 90.0},
        {"Charlie", 22, 88.0}
    };

    for (int i = 0; i < 3; i++) {
        printf("Student %d - Name: %s, Age: %d, Grade: %.2f\n", i+1, students[i].name, students[i].age, students[i].grade);
    }
    return 0;
}

Next Steps

Master Intermediate Concepts

File I/O: Learn to read from and write to files, which is crucial for data persistence.
Dynamic Memory Allocation: Practice with malloc, calloc, realloc, and free for managing memory in complex applications.
Data Structures: Study essential data structures like linked lists, stacks, queues, and trees, and understand data management concepts.
Pointers in Recursion: Be comfortable with function pointers, as they are often utilized in advanced programming techniques.
Error Handling: Develop strategies for error detection and handling, a critical part of robust programming.

Start Small Projects

Calculator Program: Create a simple calculator that supports basic arithmetic, then extend it with more complex functions.
Tic-Tac-Toe Game: Build a game like Tic-Tac-Toe or “Hangman” to improve your skills with loops, conditionals, and arrays.
Mini Database: Try creating a simple database where you can add, delete, and update records, which will help you understand concepts like file handling.
Algorithm Practice: Implement sorting algorithms (like quicksort and mergesort) and search algorithms to deepen your understanding of performance and optimization.

Join Coding Challenges

Online Platforms: Websites like LeetCode, HackerRank, and CodeSignal offer coding challenges where you can practice C programming by solving problems.

Resources

Tutorials

Neso Academy's C Programming Playlist (YouTube): Concise, well-structured tutorials for both beginners and intermediate learners.
FreeCodeCamp's C Programming Full Course (YouTube): A complete 8-hour course that goes through C programming step-by-step.

Books

Head First C by David Griffiths and Dawn Griffiths: Amazon Link - A fun, interactive way to learn C programming with exercises and hands-on examples.

Online Courses

Udemy's C Programming For Beginners Course: Udemy Link - Beginner-friendly course that’s often on discount. C basics in a structured way.

Practice Platforms

Exercism: Exercism Link - Offers programming exercises with mentor support to help you improve your skills.

Documentation and Reference

TutorialsPoint C Programming Guide: TutorialsPoint Link - A straightforward guide on C programming, covering syntax, data structures, and pointers.

Forem: Jamir Hossain

JavaScript Execution Context – How JS Code Runs Behind the Scenes

How does JavaScript code run on our computer?

What is Interpretation, and How Does it Work?

What is Compilation, and How Does it Work?

Is JavaScript a Compiled or an Interpreted Language?

JavaScript Execution Context

Code Example

Output

Global Execution Context

Creation Phase

Execution Phase

Function Execution Context

Creation Phase

Execution Phase

Function Execution Context in Nested Functions

Managing Execution Contexts with the Execution Stack

Scoping with let and const

Code Example

Conclusion

PHP OOP Part-2: Constructor and Destructor

What is a Constructor?

Code Example

Code Example

Code Example

What is a Destructor?

Code Example

PHP OOP Part-1: Introduction, Object, and Class

Introduction

What is an Object?

How to Create an Object in PHP?

Code Example:

What is a Class?

Code Example

PHP OOP Part-7: Composition vs Inheritance and Dependency Injection

Composition vs Inheritance

Code Example

Favor Composition over Inheritance

Code Example

Code Example

Dependency Injection

Code Example

Code Example

PHP OOP Part-6: Polymorphism

Code Example

Code Example

PHP OOP Part-5: Abstraction and Interface

What is Abstraction in PHP?

Code Example

Code Example

What is Interface in PHP?

Code Example

PHP OOP Part-4: Static property, method and this vs self

What is property and method?

Code Example

What is static property and method?

Code Example

Code Example

$this vs self Keyword

What is $this?

What is the self keyword?

PHP OOP Part-3: Access modifier, Encapsulation and Inheritance

What is Access Modifiers in PHP?

Code Example

What is Encapsulation?

Property-Level Encapsulation

Method-Level Encapsulation

Class-Level Encapsulation

What is Inheritance?

Code Example

What is Multi-level Inheritance?

PHP OOP Part-2: Constructor and Destructor

What is a Constructor?

Code Example

Code Example

Code Example

What is a Destructor?

Code Example

PHP OOP Part-1: Introduction, Object, and Class

Introduction

Scoping with `let` and `const`

1. Integer (`int`)

2. Floating-point (`float`)

3. Double (`double`)

4. Character (`char`)

5. Boolean (using `int`)

6. Short Integer (`short`)

7. Long Integer (`long`)

8. Unsigned Integer (`unsigned int`)