25Jul/26

PHP Functions

July 25, 2026PHPDreamMaker

Functions A Function is a block of code that performs a specific task. Instead of writing same code again and again, we can use function to reuse the code. Such type ofRead More…

25Jul/26

PHP Arrays

July 25, 2026PHPDreamMaker

An Array is a data structure that is used to store multiple values in a single variable. Instead of creating different variables for each value, we can store all values together inRead More…

07Aug/17

PHP Break, Continue and Exit

August 7, 2017PHPcontinue, exit, php-break, php-continueDreamMaker

Break: A break statement can be used to terminate or to come out from the loop or conditional statement unconditionally. It can be used in switch statement to break and come outRead More…

09Jul/17

PHP Exit Control Loop

July 9, 2017PHPdo-while-loop, php-do-while, php-exit-control-loop, php-looping-structures, php-loopsDreamMaker

An Exit Control Loop checks the condition for exit and if given condition for exit evaluate to true, control will exit from the loop body else control will enter again into theRead More…

04Jul/17

PHP Entry Control Loop

July 4, 2017PHPfor-loop, foreach, php-entry-control-loop, php-for-loop, php-foreach-loop, php-while-loop, while-loopDreamMaker

An entry control loop checks the condition at the time of entry and if condition or expression becomes true then control transfers into the body of the loop. Such type of loopRead More…

Functions

A Function is a block of code that performs a specific task.
Instead of writing same code again and again, we can use function to reuse the code.
Such type of structure improves code readability and reduces complexity that’s why it is called function.

PHP Functions

In PHP, a function is defined using the keyword function.
A function will execute only when it is called.
When we want to perform a task multiple times in a program, we can use function.

Types of Functions in PHP:

1 Built-in Functions
2 User-defined Functions

Built-in Functions:

These are the predefined functions provided by PHP.
We can directly use these functions in our program.
Example:

The above function will return the length of the string.

User-defined Functions:

These are the functions created by the user according to requirement.
Syntax:

function function_name()
{
    // code to be executed
}

Example:


";
}

greet();
?>

The above program demonstrates a simple function call.

Function with Parameters:

We can pass values to the function using parameters.
Syntax:


function function_name($param1, $param2)
{
    // code
}

Example:

The above function will print sum of two numbers.

Function with Return Value:

A function can also return value using return keyword.
Syntax:


function function_name()
{
    return value;
}

Example:

The above function will return square of a number.

Difference between Function with Parameter and Without Parameter

Without Parameter With Parameter
No input is passed Input values are passed
Fixed output Output depends on input

Conclusion:

Function is very useful in PHP to reuse code and perform specific task.
It makes program simple, readable and easy to manage.

An Array is a data structure that is used to store multiple values in a single variable.
Instead of creating different variables for each value, we can store all values together in an array.
Such type of structure makes data handling easy and organized that’s why it is called array.

PHP Arrays

In PHP, an array can store multiple values of same type or different types.
Each value in an array is identified by a key or index.

When we want to store a list of values and access them easily, we can use array structure.

PHP supports mainly three types of arrays:

Indexed Array
Associative Array
Multidimensional Array

Indexed Array:

In indexed array, each element is assigned an index number starting from 0.

Syntax:


$array_name = array(value1, value2, value3);


$array_name[0] = value1;
$array_name[1] = value2;

Example:


<?php
$colors = array("Red", "Green", "Blue");

echo $colors[0] . "<br/>";
echo $colors[1] . "<br/>";
echo $colors[2];
?>

The above program will print values using index number.

Associative Array:

In associative array, each element is assigned with a key instead of index number.

Syntax:


$array_name = array("key1" => value1, "key2" => value2);

Example:


<?php
$student = array("name" => "Rahul", "age" => 20);

echo $student["name"] . "<br/>";
echo $student["age"];
?>

The above program will print values using keys.

Multidimensional Array:

A multidimensional array is an array which contains one or more arrays inside it.

Syntax:


$array_name = array(
array(value1, value2),
array(value3, value4)
);

Example:


<?php
$marks = array(
array(50, 60),
array(70, 80)
);

echo $marks[0][0] . "<br/>";
echo $marks[1][1];
?>

The above program demonstrates accessing values from multiple dimensions.

Difference between Indexed and Associative Array

Indexed Array	Associative Array
Uses numeric index	Uses named keys
Index starts from 0	Keys are user defined
Access using index	Access using key

Conclusion:

Array is very useful in PHP to store multiple values in a single variable.
It helps to manage data efficiently and reduces complexity of the program.

સેફ વર્કિંગ પ્રેક્ટીસ

ઇલેક્ટ્રિક/ઇલેક્ટ્રોનિક સાધનો સાથે કાર્ય કરતા સાવચેતી
ઇલેક્ટ્રિકસીટી થી અક્સમાત ની સંભાવના
કોમ્પ્યુટર પર કાર્ય કરતા પહેલા સાવચેતીના પગલા
ઇલેક્ટ્રિક શોકની તીવ્રતા :
ઇલેક્ટ્રિક પ્રવાહની તીવ્રતા
પ્રવાહ ના સંપર્કની અવધી

ઇલેક્ટ્રિક શોક લાગતા લેવાના થતા સાવચેતીના પગલાઓ

ઇલેક્ટ્રિક વાયરનું જોડાણ દુર કરો
પાવર સપ્લાય બંધ કરો
ઇલેક્ટ્રિસીટીના સંપર્કમાં આવનાર વ્યક્તિને લાકડા, રબ્બર અથવા પ્લાસ્ટીક વડે દુર કરવા પ્રયત્ન કરવો
ઇલેક્ટ્રિસીટીના સંપર્કમાં આવનાર વ્યક્તિના સીધા સંપર્કમાં આવી દુર કરવા પ્રયત્ન કરવો નહિ.
મૂર્છિત થવાના કિસ્સામાં પહેરેલ કપડાને ઢીલા કરવા
પુરતા હવા/ઉજાસ વાળા વિસ્તારમાં રાખો.
શ્વાસોસ્વાસ અને હૃદયના ધબકારાનું સતત અવલોકન કરો
ડોક્ટરની તુરંત મદદ લો

આગ લાગતા લેવાની થતી સાવચેતી

ઝડપથી સાવચેતીના પગલા ભરો
આગ લાગવાના મુખ્ય ત્રણ પરિબળો ને કાબુમાં કરો :
૧. ફયુલ (બળતણ ) ના પુરવઠા પર કાપ મુકો
૨. રેતી અથવા અન્ય પદાર્થ વડે ઓક્સીજનના
પુરવઠાને અવરોધો.
૩. પાણીના ઉપયોગ દ્વારા તાપમાનને નીચું લાવો

આગ લાગતી અટકાવવા રાખવી પડતી સાવચેતીઓ

ઇલેક્ટ્રિક વાયરમાં ભંગાણ
ઇલેક્ટ્રિક વાયરમાં ઢીલું જોડાણમાં
સર્કિટમાં ઓવરલોડિંગ
તાપમાનનું સતત અવલોકન
ઇલેક્ટ્રિક વાયરમાં યોગ્ય ઇન્સ્યુલેશન
જડપથી આગ પકડતા પધાર્થો દુર રાખવા
કાર્ય પૂર્ણ થતા તમામ ઉપકરણો બંધ કરવા
કાર્ય પૂર્ણ થતા તમામ સ્વીટ્ચ બંધ કરવી
જવલંશીલ પદાર્થો નો દુર સંગ્રહ કરવો

આગનાં પ્રકારો

ક્લાસ A :
ક્લાસ B :
ક્લાસ C :
ક્લાસ D :

વિડીઓ જુવા અહી ક્લિક કરો :

કોમ્પુટર કોર્સ
તાલીમી સમયગાળો : ૦૧ વર્ષ
કુલ ૦૨ સેમેસ્ટર
પ્રવેશ માટેની લઘુત્તમ લાયકાત : ધોરણ ૧૦ પાસ
NSQF Leval : ૩.૫

એક અઠવાડિયા ના કુલ ૪૦ કલાક
ટ્રેડ પ્રેક્ટીકલ : કુલ 30 કલાક
ટ્રેડ થીયરી : કુલ ૦૬ કલાક
એમ્પ્લોયેબીલીટી સ્કીલ : કુલ ૦૨ કલાક
ઈત્તર પ્રવુતિ : કુલ ૦૨ કલાક

અભ્યાસક્રમ ( પ્રથમ સેમેસ્ટર )

કોમ્પુટર બેસિક
માઈક્રોસોફ્ટ વર્ડ
માઈક્રોસોફ્ટ એક્સેલ
માઈક્રોસોફ્ટ પાવરપોઈન્ટ
લીનકસ ઓપરેટીંગ સીસ્ટમ ઓવર વ્યુ
ડેટાબેઝ એપ્લીકેશનનો પરીચય
ઈન્ટરનેટ
નેટવર્કીન્ગ
HTML નો પરીચય

અભ્યાસક્રમ ( દ્રિતીય સેમેસ્ટર )

જાવા સ્ક્રીપ્ટ
પાઈથન
ઈ-કોમર્સ
સાયબર સિક્યોરીટી
કલાઉડ કમ્પ્યુટીંગ

STRUCTURE INSIDE THE STRUCTURE OR NESTED STRUCTURE:

Structure within structure means nesting of structure.
If we declare a structure inside another structure, then it is referred to as nested structure.
In another words, when a structure is a member of another structure, it is called a nested structure.
In following example, we have defined two structures: Address and Student.

struct address
{
   char society[100];
   char area[100];
   char city[50];
   int pcode;
};

struct student
{
   int rollno;
   char name[50];
   struct address add;		// Structure inside structure
};

In above example we have defined one structure having member variables society, area, city, and pcode and another structure having member variables roll number, name, and one structure variable of type structure “address”.
We can also define above structure by following way. Any method is valid for C program.

struct student
{
    int rollno;
    char name[50];  // Structure address defined inside the structure
     
    struct address
    {
         char society[100];
         char area[100];
         char city[50];
         int pincode;
     }add;
};

We can access the members of nested structure in program as under:

void main()
{
    struct student s;
     
    printf(“Enter student detail\n”);
    scanf(“%d”, &s.rollno);
    gets(s.name);
     
    // Accessing the member of nested structure
    gets(s.add.society);
    gets(s.add.area);
    gets(s.add.city);
    scanf(“%d”,&s.add.pincode);
}

The C99 standard specifies that at least 63 levels of nesting can be allowed.

// Write a C program to read and display information of an employee, using a nested structure.

#include “stdio.h”
typedef struct
{
     int day;
     int month;
     int year;
}DOJ;   // DOJ = Date of joining

typedef struct
{
     char name[30];
     int ID;
     DOJ doj;
     float salary;
}EMPLOYEE;

void main( )
{
     int n,i;
     printf(“\n Enter the number of Employees: ”);
     scanf(“%d”,&n);

     EMPLOYEE emp[n]; // Array of structures declaration.
     for(i=0;i<n; i++)
     {
        printf(“\n Enter %d Employee details: ”);
        printf(“\n\t Enter Employee Name: ”);
        scanf(“%s”,emp[i].name);
        
        printf(“\n\t Enter Employee ID: ”);
        scanf(“%d”,&emp[i].ID);
        printf(“\n\t Enter Employee Date of Joining: ”);
        scanf(“%d %d %d”, &emp[i].doj.day, &emp[i].doj.month,
        &emp[i].doj.year); 
       
        // Nested Structure 
        printf(“\n\t Enter Employee Salary: ”); 
        scanf(“%f”,&emp[i].salary);
     }
     printf(“\n ********** STORED INFORMATION **********”);

     for( i=0 ; i<n;i++)
     {
        printf(“Details of %d Employee: ”);
        printf(“\n\t Employee Name = %s”,emp[i].name);
        printf(“\n\t Employee ID = %d”,emp[i].ID);
        printf(“\n\t Employee Date of Joining = %d-%d-%d”,
        emp[i].doj.day,emp[i].doj.month,emp[i].doj.year);
        printf(“\n\t Em ployee Salary =%f ”,emp[i].salary); 
     } 
}

OUTPUT:

Enter the number of Employees: 2
Enter 1 Employee details:
Enter Employee Name: Sameer Shekh
Enter Employee ID: 10102
Enter Employee Date of Joining: 1 6 2013 
Enter Employee Salary: 40000    //User Input
Enter 2 Employee details:
Enter Employee Name: Aryan Kumar
Enter Employee ID: 10125
Enter Employee Date of Joining: 3 6 2013 
Enter Employee Salary: 45000 
********** STORED INFORMATION **********
Details of 1 Employee:
Employee Name = Sameer Shekh
Employee ID = 10102
Employee Date of Joining = 1 – 6 – 2013 
Employee Salary = 40000    // Program Output
Details of 2 Employee:
Employee Name = Aryan Kumar
Employee ID = 10125
Employee Date of Joining = 3 – 6 – 2013 
Employee Salary = 45000

We can create an array of structure just like we create an array of built in data type such as int, float etc.

A single structure variable can store only information of single entity. In other words, a single structure variable can store only single record.

Consider the following structure variable declaration of emp structure. Variable e1 can be used to store record of single employee only.

struct emp e1;

In practical life we need to store multiple records of multiple employees with common information for all.

In this case we can simply declare a structure variable as an array just like normal array declaration of basic data types which is called Array of Structure.

The only difference is that in array of structure each array element will be of type structure.

Syntax	Example
struct tag_name { data-type var-name1; data-type var-name2; : data-type var-nameN; };	struct product { int pid; char name[20]; int qnt; float price; };
struct tag_name struct_var[size];	struct product p1[3];

Note that structure variable p1 is declared as an array of structure. Memory representation for p1 will be as follow:

Structure variable p1 can store three records of product and we can access each individual record using array index along with structure variable name just like normal array.

For example to access first record or element we can simply use p1[0], to access second and third record p[1] and p1[2]

Individual member of structure can be accessed with the same method as we did before i.e. using dot operator along with structure variable name and member name.

For example, to access individual members of first record we can do so as follow:

Syntax:

struct_var_name [index]  . member_name

Example:

P1[0].pid  = 101;

Consider the following example where we have used array of structure to store records of five employees.

//Program to declare array of structure to store records of five employees.
#include "stdio.h"
#include "conio.h"

struct product   // structure declaration
{
	int pid;
	char name[20];
	int qnty;
	float price;
};

void main()
{
   struct product p1[5];   //structure variable declaration where P1 is array of structure 
   int i;
   for( i = 0 ; i < 5 ; i++)   //read data
   {
      printf(“\n Enter Prduct ID, Name, QNT and Price :” ) ;
      scanf(“%d %s %d %f”, &p1[i].pid, &p1[i].name, &p1[i].qnty,
      &p1[i].price);
   }
   printf(“\n ID\tName\tQNT\tPrice” ) ;
   for( i = 0 ; i < 5 ; i++)   // print data
   {
      printf(“\n%d %s %d %f”, p1[i].pid, p1[i].name, p1[i].qnty,
      p1[i].price);
   }
   getch();
}

A structure can also contain array members just like normal members such int, float
We can declare an array if we need to store multiple values inside structure.
Structure may include as many array members as we require.
Syntax for declaring array within structure is not different than the conventional syntax. The only difference is that it is declared inside the structure.

Consider the following example for storing student’s information where we have declared an array of mark to store marks of six subjects and display on the screen.

Since we need to store marks for six subjects, we have to use looping structure but the same is not true for character array of one dimension.

Array within Structure Example:

#include "stdio.h"
#include "conio.h"
#include "string.h"

struct student
{
	int rno;
	char name[20]; // Character array
	int mark[6];  // Integer Array with six elements 
	float per;
};
void main()
{
   struct student s1;   // structure variable declaration
   int tot = 0;
   
   clrscr();

   // individual member initialization.
   
   printf(“\n Enter Student Roll No :”);
   scanf(“%d”, &s1.rno);
   printf(“\n Enter Student Name :”);
   gets(s1.name);

   // read marks for six subjects using loop
  
   for(i = 0 ; i < 6 ; i++ )
   {
      printf(“\n Enter Subject %d mark :”,i+1);
      scanf(“%d”, &s1.mark[i]);
      tot = tot + s1.mark[i];
   }
   
   // calculate percentage
   
   s1.per = tot/6 ;
   printf(“\n Roll No : %d\t Name : %s”,s1.rno, s1.name);
   
   for( i = 0 ; i < 6 ; i++ )  // display marks
   {
       printf(“\n%d”,s1.mark[i]);
   }
   printf(“\nTotal : %d\t Percentage : %.2f”,tot, s1.per );
   getch();
}

In previous post we learnt about simple disk scheduling policy called first-come first-serve.

In this post we are about to explain one another disk scheduling algorithm which is widely accepted i.e. Shortest Seek Time First (SSTF) Scheduling.

Shortest Seek Time First (SSTF) Scheduling

It is reasonable to service all request close to the current head position, before moving the head far away to service other request.

This is the concept implemented for shortest seek time first algorithm.

This algorithm selects the request with minimum seek time from the current head position that means the closest request will be serviced first.

Seek time increases with the no. of cylinder traversed by the head.

It selects the pending request closest to the current head position.

It provides improvement in performance over FCFS policy.

It is the derived form of SJF scheduling algorithm that works on the same policy.

The main disadvantage of SSTF is that it may cause starvation of some request that are far away from the head position.

If new request arrives at the nearest head position continuously, then those requests which are far away will never serviced and it has to stay in a waiting state.

14 and 186 are the two requests, while servicing this request supposes 14 a new request near 14 arrives.

This new request will be serviced next making the request at 186 to be waiting.

This scenario likely to increase if the pending request queue goes long.

It is an improvement over the First Come First Serve but it is not optimal.

In my previous post titled “Disk Scheduling”, I tried to explain about the fundamentals of disk scheduling.

In this and upcoming posts, we will look some of the widely used disk scheduling algorithms.

In this post, I will start with the most simple and commonly used disk scheduling algorithm called First Come First Serve (FCFS).

First Come First Serve (FCFS)

This is the simplest form of scheduling.

It is similar to the FIFO CPU scheduling algorithm.

According to FCFS algorithm, all requests will be serviced in the same order in which they arrive.

In other words, request will be serviced in the sequential manner.

It does not provide the fastest access and it is also not optimal.

It has higher seek time compare to other algorithms.

For example, A disk queue with request of input, output of two blocks on cylinders are as 98, 183, 37, 122, 14, 124, 65, 67.

If disk head is initially at cylinder 53 than it will move from 53 to 98 that is the end of the request of the block and to 183, 37 and so on.

We can see total head movements and cylinders to be traveled from the request servicing queue.

If the request for cylinders is 37 and 14 to be serviced together before or after the request at 122 and 124, the total head movement could be decreased and performance could be improved.

In my previous post I discussed about Structure and its basic concept. In this post I will discuss how a structure can be declared and initialized and how to deal with it.

We can declare a structure using “struct” keyword. A structure must be declared first before using it just like all other data type. Structure can be declared by two ways.

Tagged Declaration
Typedef Declaration

Tagged Declaration:

Tagged declaration starts with the keyword “struct” followed by the tag name (structure name).

Syntax	Example
struct tag_name { data-type var-name1; data-type var-name2; : data-type var-nameN; };	struct product { int pid; char name[20]; int qnt; float price; };

Typedef Declaration:

Typedef declaration differs from tagged declaration in two ways:

Keyword “typedef” is placed at the beginning of the declaration.
It requires identifier at the end of structure block (“}”) and before the semicolon (;).

Syntax	Example
typedef struct { data-type var-name1; data-type var-name2; : data-type var-nameN; }identifier;	typedef struct { int pid; char name[20]; int qnt; float price; } product;

Structure Variable Declaration

Once structure is declared we can create variables of structure type.
Structure variable can be declared either globally or locally.

Global declaration of structure variable:

When we declare structure variable outside the main () function then it becomes global and it can be accessed from anywhere within the program.
Structure variable can be declared using the following syntax:

struct <struct_name> var-name;

The following example declares global structure variable using tagged structure declaration.

Example	Short hand Method
struct product { int pid; char name[20]; int qnt; float price; }; struct product p1,p2; // global declaration void main() { // main body }	struct product { int pid; char name[20]; int qnt; float price; } p1,p2; void main() { // main body }

The following example uses typedef declaration to declare global structure variable.

Example

typedef struct
{
   int pid;
   char name[20];
   int qnt;
   float price;
} product;
product p1,p2;  // global declaration

Local declaration of structure variable:

Structure variable can be declared as local by declaring it inside the main () function as follow:

Tagged Declaration Example	Typedef Declaration Example
struct product { int pid; char name[20]; int qnt; float price; }; void main() { // Local declaration struct product p1,p2; }	typedef struct { int pid; char name[20]; int qnt; float price; } product; void main() { // Local declaration product p1,p2; }

Memory representation for the structure variable can be given as shown into the below figure.

Each structure member is allocated separate memory area.
Total memory required by the structure variable can be calculated as follow:

pid (int ) = 2 bytes + name (char) 20 bytes + qnt (int) 2 bytes + price(float) 4 bytes = 28 bytes

Accessing Structure Members

We can access individual structure members using two operators:

The structure member operator (.) also called as “direct selection operator”, “dot” or “period” operator.
The structure pointer operator (-> ) also called as “arrow operator”.

To refer to a member in a structure we need to refer to both the structure variable and structure member respectively.

Syntax :

struct-var .member-name

The pointer operator –consisting of a minus sign (-) and a greater than ( > ) sign without space in between.

It accesses a structure member via a pointer to the structure.

Initialization of Structure Variable

Initialization of structure variable can be done in two ways:

Static initialization
Dynamic Initialization

Static Initialization Example:

struct product
{
   int pid;
   char name[20];
   int qnt;
   float price;
};
void main()
{
   struct product p1,p2;
   
   // individual member initialization.
   
   p1.pid = 101 ;
   strcpy( p1.name , “Laptop” );
   p1.qnty = 10 ;
   p1.price = 35000.00 ;

   // group initialization method

   p2 = {102 , “Mobile” , 150 , 12000.00 } ;
}

Dynamic Initialization Example:


struct product
{
   int pid;
   char name[20];
   int qnt;
   float price;
};

void main()
{
   struct product p1;
   // member initialization using scanf () function.

   printf(“\n Enter Prduct ID, Name, QNT and Price :” ) ;
   scanf(“%d %s %d %f”, &p1.pid, &p1.name, &p1.qnty, &p1.price ) ;
   printf(“%d %s %d %f”, p1.pid, p1.name, p1.qnty, p1.price ) ;

}