Forem: Montasser Mossallem

Build a RESTful API in PHP Without a Framework

Montasser Mossallem — Sat, 10 May 2025 06:50:26 +0000

APIs allow software systems to talk to each other. A RESTful API follows a set of rules for structuring requests and responses. In this tutorial, you’ll learn how to build a simple REST API using plain PHP.

What Is a RESTful API?
Project Setup
Directory Structure
Create the .htaccess File
Routing Requests
Build the Controller
Handle API Methods (GET, POST, PUT, DELETE)
Return JSON Responses
Test Your API
Conclusion

What Is a RESTful API?

REST stands for Representational State Transfer. A RESTful API uses standard HTTP methods to perform operations:

GET – fetch data
POST – add new data
PUT – update existing data
DELETE – remove data

Each request must return a structured response, usually in JSON format.

Project Setup

Create a new folder for the project:

mkdir php-rest-api
cd php-rest-api

You need:

PHP 7.4+ (or 8.x)
Apache with mod_rewrite enabled
A tool like Postman for testing

Directory Structure

Create this structure:

php-rest-api/
├── api/
│   └── index.php
├── .htaccess
└── data.json

index.php: main API logic
data.json: mock database
.htaccess: rewrite rules for clean URLs

Create the .htaccess File

Enable clean URLs and route all requests to index.php.

# .htaccess
RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^ api/index.php [QSA,L]
Make sure AllowOverride All is enabled in your Apache config.

Routing Requests

In api/index.php, route requests by URL and method.

<?php

header("Content-Type: application/json");

$method = $_SERVER['REQUEST_METHOD'];
$request = explode("/", trim($_SERVER['PATH_INFO'] ?? '', "/"));

$resource = $request[0] ?? null;
$id = $request[1] ?? null;

require_once 'controller.php';

handleRequest($method, $resource, $id);

Build the Controller

Create a controller.php file inside api/.

<?php

function handleRequest($method, $resource, $id) {
    if ($resource !== 'items') {
        http_response_code(404);
        echo json_encode(["error" => "Resource not found"]);
        return;
    }

    $data = json_decode(file_get_contents(__DIR__ . '/../data.json'), true);

    switch ($method) {
        case 'GET':
            if ($id === null) {
                echo json_encode($data);
            } else {
                $item = $data[$id] ?? null;
                if ($item) {
                    echo json_encode($item);
                } else {
                    http_response_code(404);
                    echo json_encode(["error" => "Item not found"]);
                }
            }
            break;

        case 'POST':
            $input = json_decode(file_get_contents("php://input"), true);
            $id = uniqid();
            $data[$id] = $input;
            file_put_contents(__DIR__ . '/../data.json', json_encode($data, JSON_PRETTY_PRINT));
            http_response_code(201);
            echo json_encode(["id" => $id]);
            break;

        case 'PUT':
            if ($id === null || !isset($data[$id])) {
                http_response_code(404);
                echo json_encode(["error" => "Item not found"]);
                return;
            }
            $input = json_decode(file_get_contents("php://input"), true);
            $data[$id] = $input;
            file_put_contents(__DIR__ . '/../data.json', json_encode($data, JSON_PRETTY_PRINT));
            echo json_encode(["success" => true]);
            break;

        case 'DELETE':
            if ($id === null || !isset($data[$id])) {
                http_response_code(404);
                echo json_encode(["error" => "Item not found"]);
                return;
            }
            unset($data[$id]);
            file_put_contents(__DIR__ . '/../data.json', json_encode($data, JSON_PRETTY_PRINT));
            echo json_encode(["success" => true]);
            break;

        default:
            http_response_code(405);
            echo json_encode(["error" => "Method not allowed"]);
    }
}

Handle API Methods (GET, POST, PUT, DELETE)

Use tools like Postman or curl:
GET All Items

GET /items

GET Single Item

GET /items/{id}

POST New Item

POST /items
Content-Type: application/json

{
  "name": "New Item",
  "price": 10
}

PUT Update Item

PUT /items/{id}
Content-Type: application/json

{
  "name": "Updated Item",
  "price": 20
}

DELETE Item

DELETE /items/{id}

Return JSON Responses

The API uses header("Content-Type: application/json") and echo json_encode(...) to return data in a machine-readable format.

Test Your API

You can test it using:

Postman: GUI tool for API testing
curl: command-line tool
JavaScript fetch() or Axios in the browser

Conclusion

You just built a fully working RESTful API in PHP. You handled routing, methods, and JSON responses—all without a framework. This is great for learning or small-scale projects.

Next steps:

Connect to a real database (MySQL or SQLite)
Add authentication (JWT, API key)
Add validation and error handling

Thank you for reading.

Resources

Understand How the Abstract Class Works in PHP

Montasser Mossallem — Sun, 13 Apr 2025 15:10:09 +0000

An abstract class in PHP is a class that cannot be instantiated directly. Instead, it serves as a base class that other classes extend.

It can include both defined methods (with code) and abstract methods (without code).

The Syntax of Abstract Class Works in PHP

Here is the basic concept:

Use the abstract keyword to define it.
Can include regular properties and methods.
Must be extended by another class.
Cannot be used to create objects directly.
Can include abstract methods—these have no body and must be implemented by child classes.

Here is an example:

abstract class SmartDevice {
  abstract public function activate();

  public function status() {
    echo "Device is online";
  }
}

Abstract classes define a shared structure for child classes. They help you to:

Make sure each child class defines the required methods.
Allow shared behavior across similar objects.
Keep code organized and reusable.

class SmartLight extends SmartDevice {
  public function activate() {
    echo "Light turned on\n";
  }
}

$device = new SmartLight();
$device->activate();
$device->status();

Here is its output:

Light turned on
Device is online

This example shows you how SmartDevice provides a base for different smart devices like lights, thermostats, or alarms. Each subclass defines its own way to activate the device.

Abstract Class vs Interface in PHP

Abstract Class:

Cannot be instantiated.
Can include both abstract and normal methods.
Can have properties (with values).
A class can extend one abstract class.
Can use public, protected, private.
Allows shared logic through defined methods.

Interface:

Cannot be instantiated.
Only method declarations.
Cannot have properties (until PHP 8.1).
A class can implement multiple interfaces.
All methods are public.
No shared logic, only structure.

So the question is: when to use each one?

Use an abstract class when:

You want to define shared behavior across related classes.
You need to include properties and method implementations.
If you want to provide a default implementation that can be reused or overridden.

Use an interface when:

You want to define a contract with no implementation.
If you need to enforce method structure across unrelated classes.
You need to implement multiple interfaces in one class.

How to Extend an Abstract Class in PHP

Apply the extends keyword to create a subclass from an abstract class. The child class must implement all abstract methods from the parent class.

For example:

abstract class SmartDevice {
  abstract public function activate();

  public function status() {
    echo "Device is online\n";
  }
}

class SmartFan extends SmartDevice {
  public function activate() {
    echo "Fan turned on\n";
  }
}

Here:

SmartDevice is the abstract class.
SmartFan extends it and must define activate().

You can also override an abstract method when you provide its full definition in the child class.

The method name, parameters, and visibility must match.

class SmartSpeaker extends SmartDevice {
  public function activate() {
    echo "Speaker playing music\n";
  }
}

You can also override non-abstract methods if needed:

class SmartSpeaker extends SmartDevice {
  public function activate() {
    echo "Speaker playing music\n";
  }

  public function status() {
    echo "Speaker is connected\n";
  }
}

The status() is not abstract, but you can override it if behavior needs to change.

So, we can say:

All abstract methods must be implemented.
Method signature must match exactly.
You can override regular methods if needed.

Abstract Class with Constructor in PHP

An abstract class can have a constructor. This lets you define shared setup logic for all child classes.

For example:

abstract class SmartDevice {
  protected $name;

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

  abstract public function activate();

  public function status() {
    echo "$this->name is online\n";
  }
}

When a child class extends the abstract class, it can:

Inherit the constructor as-is.
Call the parent constructor using parent::__construct().
Add extra setup logic in its own constructor.

class SmartThermostat extends SmartDevice {
  private $temperature;

  public function __construct($name, $temperature) {
    parent::__construct($name);
    $this->temperature = $temperature;
  }

  public function activate() {
    echo "$this->name set to $this->temperature °C\n";
  }
}

$device = new SmartThermostat("Living Room Thermostat", 22);
$device->activate();   
$device->status();

Here is the output:

Living Room Thermostat set to 22 °C
Living Room Thermostat is online

Abstract classes can have constructors.
Use parent::__construct() to call the parent constructor.
Pass values through the child constructor as needed.

Wrapping Up

Abstract classes in PHP are classes that can’t be used to create an object on their own. They serve as a foundation for other classes to inherit from.

They can include both abstract methods (without code) and regular methods (with code). Any child class that extends an abstract class must implement the abstract methods.

Thank you for reading. If you would like to read more PHP tutorials, please visit our blog, FlatCoding or navigate to PHP manual.

JavaScript Hello World: A Simple Introduction

Montasser Mossallem — Sun, 06 Apr 2025 18:36:36 +0000

JavaScript is a popular programming language used for web development. Here's how to create a simple "Hello World" program in JavaScript.

Create an HTML File

First, create an HTML file. This file will contain the structure of your webpage and run the JavaScript code.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Hello World in JavaScript</title>
</head>
<body>
    <h1>Welcome to JavaScript!</h1>
    <p id="greeting"></p>

    <script>
        // Your JavaScript code will go here
        document.getElementById("greeting").innerText = "Hello World!";
    </script>
</body>
</html>

Add JavaScript Code

Inside the <script> tag, you can write JavaScript. In this case, the code changes the text of a paragraph with the id="greeting" to "Hello World!".

document.getElementById("greeting").innerText = "Hello World!";

This line of code accesses the HTML element with the ID greeting and changes its text content to "Hello World!".

Open the HTML File

Once you’ve saved the file with a .html extension, open it in a web browser. You’ll see the page display "Welcome to JavaScript!" and "Hello World!" in the paragraph below it.

document.getElementById("greeting"): This method finds the element with the ID greeting in the HTML.
innerText = "Hello World!": This sets the content of the selected element to "Hello World!".

You find the fill example in codepen

Conclusion

This is the simplest way to write JavaScript that interacts with an HTML page. You can use this basic setup to start exploring JavaScript further and adding more functionality to your web pages.

Forem: Montasser Mossallem

Build a RESTful API in PHP Without a Framework

Table of Contents

What Is a RESTful API?

Project Setup

Directory Structure

Create the .htaccess File

Routing Requests

Build the Controller

Handle API Methods (GET, POST, PUT, DELETE)

Return JSON Responses

Test Your API

Conclusion

Resources

Understand How the Abstract Class Works in PHP

The Syntax of Abstract Class Works in PHP

Abstract Class vs Interface in PHP

How to Extend an Abstract Class in PHP

Abstract Class with Constructor in PHP

Wrapping Up

JavaScript Hello World: A Simple Introduction

Create an HTML File

Add JavaScript Code

Open the HTML File

Conclusion