Web Development Articles

A Quick HowTo of PHP Operators

0 👍
👎 0
 LAMP

Math Operators

Addition:
Caculate the sum of two numbers using the + operator.

$sum = 1 + 3;
The value of $sum is 4.

Subtraction:
Caculate the difference of two numbers using the - operator.

$diff = 3 - 2;
The value of $diff is 1.

Division:
Calculate the quotient of two numbers using the / operator.

$quotient = 4 / 2;
The value of $quotient is 2.

Multiplication:
Calculate the product using the * operator.

$product = 4 * 5;
The value of $product is 20.

Modulo:
Gives the remainder after dividing two numbers the % operator.

$remainder = 10 % 3;
The value of $remainder is 1.

PHP Object Oriented Class Inheritance

0 👍
👎 0
 PHP
 LAMP

PHP class inheritance is a mechanism that allows one class (called the child class or subclass) to inherit properties and methods from another class (called the parent class or superclass).

 

This allows you to reuse code, extend existing functionality, and follow the principle of "Don’t Repeat Yourself (DRY)".


Basics of Inheritance

1. The extends keyword is used in PHP to create inheritance.

2. A child class automatically inherits all the public and protected properties and methods of its parent class.

3. The child class can:

       A. Use the inherited methods and properties directly.

       B. Override methods from the parent class.

       C. Add new methods and properties.

 

Example 1: Basic Inheritance

Here, the Dog class inherits from the Animal class but overrides the speak() method.

 

 // Parent class

 class Animal {

    public $name;

 

    public function __construct($name) {

        $this->name = $name;

    }

 

    public function speak() {

        echo "$this->name makes a sound.<br>";

    }

 }

 

 // Child class

 class Dog extends Animal {

    public function speak() {

        echo "$this->name barks! Woof Woof!<br>";

    }

 }

 

 // Usage

 $animal = new Animal("Generic Animal");

 $animal->speak(); // Output: Generic Animal makes a sound.

 

 $dog = new Dog("Buddy");

 $dog->speak(); // Output: Buddy barks! Woof Woof!

 

 

Example 2: Using parent:: to Call Parent Methods

The Car class overrides the start() method but still uses the parent’s method with parent::start().

 

 class Vehicle {

    public function start() {

        echo "Starting the vehicle...<br>";

    }

 }

 

 class Car extends Vehicle {

    public function start() {

        // Call the parent method first

        parent::start();

        echo "Car engine started!<br>";

    }

 }

 

 $car = new Car();

 $car->start();

 // Output:

 // Starting the vehicle...

 // Car engine started!

 

 

Example 3: Multilevel Inheritance

Human inherits from Animal, and Animal inherits from LivingBeing. So, Human has all methods from both parents.

 

 class LivingBeing {

    public function breathe() {

        echo "Breathing...<br>";

    }

 }

 

 class Animal extends LivingBeing {

    public function eat() {

        echo "Eating...<br>";

    }

 }

 

 class Human extends Animal {

    public function speak() {

        echo "Speaking...<br>";

    }

 }

 

 $person = new Human();

 $person->breathe(); // From LivingBeing

 $person->eat();     // From Animal

 $person->speak();   // From Human

 

 

JavaScript Variable Types (var, const, let)

0 👍
👎 0
 MySQL

There are 3 types of variables commonly used in javascript.  The main difference with the let type it's block scope.  If it's defined inside of a block it can't be accessed outside of the block.   Let's look at each in more detail:

const

Variables defined with const cannot be Redeclared
Variables defined with const cannot be Reassigned
Variables defined with const have Block Scope


// INCORRECT - must be assigned a value when it's declared.
const x;  
x = 1.999;

// INCORRECT - it cannot be reassigned a value
const x = 1.999;

x = 8;  

// IF defined inside of a block it has block scope. Look at example below:
if( somecondition )
{
   const x = 9;
}
// x cannot be access here outside of the "block", curly brackets.
// Below are valid usage of const:
// Example 1:
if( condition )
{
   const x = 8;
   console.log(x);
}

// Example 2:
const x = 8;
if( condition )
{
   console.log(x);
}


Defining a Javascript Function

0 👍
👎 0
 NodeJS
 Javascript

How To Define a JavaScript Function

There are a few different ways to declare a function in Javascript applications. I’ve laid out 4 ways below so choose the method that best fits your use case! Function declarations are great for named functions, whereas arrow functions are excellent for callbacks and shorter functions.  

Using Function Declaration

 

 /** Function Declaration */

 function functionName(parameters) {

    // code to be executed

    return value;

 }

 

 // Example

 function greet(name) {

    return "Hello, " + name + "!";

 }

 console.log(`My name is ${greet("Alice")}`); // "Hello, Alice!"

 

 

Using Function Expression

 

 /** Function Expression */

 const functionName = function(parameters) {

    // code to be executed

    return value;

 };

 

 // Example

 const multiply = function(a, b) {

    return a * b;

 };

 console.log(`5 * 3 = ${multiply(5, 3)}`); // 15

 

 

Using Arrow Functions (ES6)

 

 /** Arrow Function (ES6) */

 const functionName = (parameters) => {

    // code to be executed

    return value;

 };

 

 // Examples with different syntax

 const square = (x) => {

    return x * x;

 };

 console.log(`Square of 4: ${square(4)}`); // 16

 

 // Implicit return (for single expressions)

 const squareRoot = x => x ** 0.5;

 console.log(`Square Root of 8: ${squareRoot(8)}`);

 

 // Multiple parameters

 const add = (a, b) => a + b;

 console.log(`2 + 3 = ${add(2, 3)}`); // 5

 

 // No parameters

 const title = () => "Math";

 console.log(`The page title is "${pageTitle()}"`);

 

 

Using the Function Constructor

 

 /** 4. Function Constructor (less common) */

 const functionName = new Function("parameters", "function body");

 

 // Example

 const divide = new Function("a", "b", "return a / b;");

 console.log(divide(10, 2)); // 5

 



Javascript Spread Operator ...

0 👍
👎 0
 MongoDB

The javascript spread operator ... is a convenient way to insert an array into a second array.  Used mainly when defining the array data.  Consider the following:

/****
 * The x array is placed inside of noSpread as a child array inside.
 * noSpread array is now ['u', Array(2), 3, 7]
 ****/
let x = ['a', 2];
let noSpread = ['u', x, 3, 7];

/***
 * using the spread operator ...x
 * the spread array is now ['u', 'a', 2, 5, 6]
 ***/
 
let x = ['a', 2];
let spread = ['u', ...x, 5, 6];

 

PostgreSQL many-to-many Relationship

0 👍
👎 0
 PostgreSQL

In this example we will look at how to work with a many-to-many relationship.  So first let’s look at a situation where we can leverage a many-to-many relationship.  Imagine we have both Students and Courses.  A student can be enrolled in multiple courses and a course can have multiple students.  This is called a many-to-many relationship and requires what’s called a pivot table.  Although there aren’t any restrictions to the name of a pivot table I will call it “course_student”.  The course_student pivot table will have, at minimum, 2 foreign key fields.  A reference to courses table and a reference to students table.  

 

 

 CREATE TABLE students (

   id INT PRIMARY KEY AUTO_INCREMENT,

   name VARCHAR(100) NOT NULL,

   phone_number VARCHAR(100) UNIQUE NOT NULL,

 

 );

 

 CREATE TABLE courses (

   id INT PRIMARY KEY AUTO_INCREMENT,

   title VARCHAR(100) NOT NULL,

   description TEXT NOT NULL

 );

 

 -- The pivot table has a reference key to each table

 CREATE TABLE course_student (

   student_id INT,

   course_id INT,

   PRIMARY KEY (student_id, course_id),

   FOREIGN KEY (student_id) REFERENCES students(id) ON DELETE CASCADE,

   FOREIGN KEY (course_id) REFERENCES courses(id) ON DELETE CASCADE
);

 

Below are a few useful ways to query this schema. Assuming you are familiar with a LEFT JOIN, these queries specifically use LEFT JOIN for connecting the three tables. courses to course_student to students


# Get all courses that student with id = 2 is enrolled

SELECT c.id course_id, c.title, s.id student_id, s.name

FROM students s

LEFT JOIN course_student cs ON s.id = cs.student_id

LEFT JOIN course c ON c.id = cs.course_id

WHERE s.id = 2;

 

# Get all students enrolled in course with id = 1

 SELECT c.id course_id, c.title, s.id student_id, s.name

 FROM courses c

 LEFT JOIN course_student cs ON c.id = cs.course_id

 LEFT JOIN student s ON s.id = cs.student_id

 WHERE c.id = 1;

 

 

PHP Null Coalescing Nesting AND Chaining

0 👍
👎 0
 Laravel
 PHP

PHP Null Coalescing Nesting AND Chaining

The null coalescing operator is essential for writing clean, safe PHP code that gracefully handles missing data without generating warnings or errors.

 

Null Coalescing Assignment Operator (??)

 

 // ternary operator usage

 $value = isset($a) ? $a : (isset($b) ? $b : $c);

 

 // null-coalescing shorthand for above solution

 $value = $a ?? $b ?? $c;



Null Coalescing Assignment Operator (??=)

 

 // Only assign if variable is null or doesn't exist

 $array['key'] ??= 'default value';

 $user->name ??= 'Anonymous';

 

 // Equivalent to:

 if (!isset($array['key'])) {

    $array['key'] = 'default value';

 }

 

 

Use with error suppression

 

 $value = $object->property->nestedProperty ?: 'default';

 echo "Value: ".$value."\r\n"; //Warning is thrown

 

 

 $value = @$object->property->nestedProperty ?? 'default';

 echo "Value: ".$value."\r\n"; // Value: default