Overview

In this tutorial we’ll be creating a very simple blog system. We won’t be using OOP yet in this tutorial. For creating a Blog using OOP in PHP, another more advanced tutorial will be written and posted as well. The same goes for creating a more advance CMS. However in this tutorial will just be creating a simple Blog system with php functions. Functions will be created for:

• Connecting to Host & DB
• Adding posts
• Deleting posts
• Adding replies
• Deleting replies
• Creating categories
• Retrieving & Displaying Posts
• Add user
• Edit user profile
• Display user profile
• Search

Also a simple 2 rows div layout will be created with a side-menu and main content div.

Database

Let’s start with creating the database for our simple blog. We’ll call it ‘simple_blog’. However you can call it anything you like as long as you set it correctly in the script later on. Now let’s create the tables inside this database.

Table: posts

The fields that need to be created:

[TABLE=6]

SQL:

CREATE TABLE IF NOT EXISTS `posts` (
  `id` int(250) NOT NULL AUTO_INCREMENT,
  `title` varchar(50) NOT NULL,
  `author` int(250) NOT NULL,
  `message` longtext NOT NULL,
  `timestamp` int(250) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

Table: replies

[TABLE=9]

CREATE TABLE IF NOT EXISTS `replies` (
  `id` int(250) NOT NULL AUTO_INCREMENT,
  `postid` int(250) NOT NULL,
  `author` int(250) NOT NULL,
  `message` mediumtext NOT NULL,
  `timestamp` int(250) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

Table: categories

[TABLE=10]

CREATE TABLE IF NOT EXISTS `categories` (
  `id` int(250) NOT NULL AUTO_INCREMENT,
  `name` varchar(50) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

Table: members

[TABLE=11]

CREATE TABLE IF NOT EXISTS `members` (
  `id` int(250) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) NOT NULL,
  `password` varchar(50) NOT NULL,
  `email` varchar(250) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

Files

Now we’ve created our database, so let’s start with an overview of the files we’ll be creating now.

• functions.php
• config.php
• profile.php
• index.php
• post.php
• includes/header.php
• includes/footer.php
• includes/sidebar.php
• admin/index.php
• admin/functions.php

Let’s start with creating our function to connect  to the database we just made.

File: functions.php

<?php

function connect($connection) {

  $host = $connection[‘host’];
  $user = $connection[‘user’];
  $pass = $connection[‘pass’];
  $db    = $connection[‘db’];
  $conn =  mysql_connect($host, $user, $pass);

  If(!$conn)
    die(“Couldn’t connect to host.”);

  $db = mysql_select_db($db);

  If(!$db)
     die(“Couldn’t connect to database.”);

}

?>

Allright so first you see we set an argrument variable ‘$connection’ for the function. This variable should be given when calling the function and should contain all host & database info required to connect to the host & database. As you can see inside the function it seperates the sub-variables of the $connection variable into 4 new variables. These are for the host, user, password and database (db). As these are the data required to connect to the host & database and should be set in an array $connection and given to this function with sub-variable ‘host’, ‘user’, ‘pass’ and ‘db’.

We’ll be offering the $connection variable to the function as an array. It will use the sub-variable named ‘host’,  ‘user’, ‘pass’ and ‘db’ to try to establish a connection to the host and database. So these we’ll need to set in our config.php file. We’ll shorten the name of the variable $connection to $conn. As the name of it doesn’t really matter as long as we give it to the function ‘connect’ when calling it.

File: config.php

<?php

####CONNECTION CONFIGURATION###
$conn[‘host’] = “localhost”;        // database host (name/IP)
$conn[‘user’] = “root”;                // database host username
$conn[‘pass’] = “password”;      // database host password
$conn[‘db’]    = “simple_blog”; //database name

?>

With this info our function ‘connect’ should be able to establish a connection to the host & database.

We set each sub-variable for the $conn array. So we’ve got one variable ( array ) that contains all sub-variables, all info required for establishing a connection to the database. Which our function connect will accomplish.

Let’s include these files to the index file already.

File: index.php

<?php

include(“functions.php”);

include(“config.php”);

?>

We can already use our function to connect to the host & database:

File: index.php

<?php

include(“functions.php”);

include(“config.php”);

connect($conn);

?>

We provide the array variable $conn to the function which contains all the sub-variables data of host & database ( as we set it in config.php ) required for establishing a connection.

End of part 1

That’s it so far! In this part we’ve createn the structure of the script for both files, functions & database purpose. And also we’ve made our first function to establish a connection to the database & host using the configurations for the  connection set in our config.php file we created. In the second part we’ll be creating a basic CSS, Div based 2 columns layout. With a side-bar menu and a main content area where all posts will be appearing. Hope to see you in the next part!

It’s also possible to have a second class which extends the main class. This make the class able to use the (public) functions (methods) & properties of the main class inside the other class. To extend a class we use extends.

Example:

class BasicClass {

}

class Class2 extends BasicClass {

}

Here Class2 extends the class ‘BasicClass’ which means it will be able to use all the functions and variables/constabnts of this class. However in this example those are none.

Using parent functions inside extending class

[b]Note:[/b] The examples in this tutorial are just to show how extending classes works and what possiblities it has, what it’s cappable of.

As mentioned above it’s possible to use functions of the basic class ( parent class ) inside the extending class ( which extends the basic class ). Here we’ll be doing this. Let’s say we’ve got a basic class which has functions to set the name, age and gender of a human (/colleagues for example). Now we could have multiple other classes which make use of these functions ( extend the basic class ), each representing ne colleague/human.

Note: this is just an example to show how it works and how extending classes can make use of functions set in a basic class.

Example:

class Colleague {

   protected function setName($name) {

       $this->name = $name;

   }

   protected function setGender($gender) {

       $this->gender= $gender;

   }   

   protected function setAge($age) {

       $this->age= $age;

   }   

}

class Colleague1 extends Colleague{

     parent::setName("Peter");
     parent::setGender("Male");
     parent::setAge("22");

}

class Colleague2 extends Colleague{

     parent::setName("Kim");
     parent::setGender("Female");
     parent::setAge("20");

}

However this might not be such practical to do, a more practical use ( example ) is shown below. But this example is though a good example to easily understand what it’s cappable of ( extending classes ) theoretical and how it can be used.

Ok, so here we created one basic class which indicate the basic functions and properties for a colleage. Each colleague was made a class for ( 2 colleagues in this example ) using these functions to set the basic properties for each colleague. Let’s first have a look at the ’setName’ function of the basic ( parent ) class ‘Colleague’:

   protected function setName($name) {

       $this->name = $name;

   }

It’s a protected function so only the extending class can use it. It sets the variable ‘name’ which will also be able to be used in the extending class ( as that one makes use of all functions AND properties/variables of the parent/basic class ). You could as well make it a public function so that the user can use it outside the class to set the name of the colleague manually ( as done in the 2nd example/part of this tutorial ). Here though we made it a protected function so we’ll use it inside the extending class which brings us to the extending class ‘Colleague1′ which sets the name with the following code:

     parent::setName("Peter");

Or mainly:

     parent::setName("name");

This uses the parent and :: symbols to access the parent class ( the class that it extends: ‘Colleague’ ). This method works like this:

     parent::functionName();

To access a function of the parent class and:

     parent::$variablename;

to access a variable of the parent class.

The parent class just uses $this->variableName to set the variables as they’re “global” – able to being used in any other class that extends this class.

Example of output from object:

<?php

class Colleague {

   protected function setName($name) {

       $this->name = $name;

   }

   protected function setGender($gender) {

       $this->gender= $gender;

   }   

   protected function setAge($age) {

       $this->age= $age;

   }   

}

class Colleague1 extends Colleague{

     parent::setName("Peter");
     parent::setGender("Male");
     parent::setAge("22");

}

class Colleague2 extends Colleague{

     parent::setName("Kim");
     parent::setGender("Female");
     parent::setAge("20");

}
########CREATE OBJECT (OUTPUT EXAMPLE)########
     $coll1 = new colleague1;
     $coll1->name; //outputs the name which is set using the parent function setName and is set to 'Peter' in this class
     $coll2 = new colleague2;
     $coll2->name; //outputs the name which is set using the parent function setName and is set to 'Kim' in this class

?>

Using parent functions outside the extending class ( as object )

It’s also possible to have a basic class set the functions that the extending class needs to be cappable of. For example: SHOWING the name, instead of SETTING the name. Then we could have the class that extends it, create a function to set the name. So when an object of the class is created, we can set the name and use the function of the parent class as well to show the name. However we do need to make the functions of the basic class ( parent ) public as we want to use it outside the class ( wih the object, to show the name ).

class Colleague{

    public function showName() {

       return $this->name;

   }

}

class Colleague1 extends Colleague{

     public function setName($name) {

              $this->name = $name;

     }

}

So the extending class has his function to set the name, and uses the function of the basic class to be cappable of showing the name. We could create an object that shows us that it’s cappable of this:

$coll = new colleague1;
$coll->setName("Peter"); //set name, uses the function set in this extending class
echo $coll->showName(); //show name, uses the function set in the parent class (basic class: Colleague)

Preknowledge

For this tutorial it’s prefered that you’ve got some preknowledge about php variables, arrays, functions and the foreach loop. If not, I’d recommend you to have a look at the following tutorials which apply well to this tutorial:

• PHP Variables
• PHP Arrays
• Foreach Loop

Functions & Loops used

The functions/loops used in this tutorial:

Creating the function

Let’s first create a function which will do this job – replacing all smiley tags by smiley images. The only thing the function needs to do this task is a string ( text ) to do this for and an array of all smiley tags & corresponding smiley images to replace them with inside the string.

function replaceSmilies($str, $smilies) {

}

We gave them as argruments for the function, we called the string that needs to be given: ‘$str’, and the array with smiley tags & images that need to be set: ‘$smilies’.

Setting up smilies syntaxes & images

Note: This part should be put outside the function as it’s just for setting up the smiley tags & images ( example ) and an example string to replace them in. In other words: setting up the variables that are required for the function to do his task. The variables that we’ll be working with inside the function to replace the smileys.

The first thing we’re going to do is set up a list of smiley ‘tags’, syntaxes ( such as : ) and : D, etc. ) and the corresponding image icons (smilies) for those tags. We’re going to create an array to do this.

An array can be created like this:

$myArr = array("key" => "value", "key2" => "value2");

In our case we’ll set the keys equal to the smilie tags and the values equal to the smilie images ( icons ) with which these tags need to be replaced with.

Example:

$smilies = array(":)" => "smile.jpg",
                 ":P" => "thongue.jpg");

Here I just set up 2 smilies but setup as many as you want. The image names I used (’smile.jpg’ and ‘thongue.jpg’) can be any image that contains the smiley icon you want to show up for this smiley tag.

What we’ll want to do inside the replaceSmilies function is replace the keys (smiley tags) of the array by the images of the values (smilies) of the array.

Now let’s as well create an example text ( string ) in which these smiley tags occur and need to be replaced by the smiley icons/images:

$str = "Hi there!   Example text  ";

So now we’ve setup the argruments ( variables/arrays ) that are needed for our function that we’ll be creating. So let’s put everything together for so far:

<?php
function replaceSmilies($str, $smilies) {

}

$smilies = array(":)" => "smile.jpg",
                 ":P" => "thongue.jpg");
$str = "Hi there!   Example text  ";
?>

Creating the loop

Now we’re going to create a foreach loop which we’ll let it put the keys ( smiley tags ) of the array into a variable ‘$tag’ and the values ( smiley images ) into a variable ‘$image’. However it will do this for only 1 couple of a key and a value per time and execute the loop for that couple of a smiley tag and a smiley image. We’ll put the loop inside the function as the function will need to do the replacing of these smiley tags by these smiley images.

Structure of a foreach loop:

foreach($array as $keyvariable => $valuevariable) {

}

becomes =>

Our foreach loop:

foreach($smilies as $tag => $image) {

}

$smilies is the array we created to put all smiley tags ( keys ) and smiley images ( values ) into. As mentioned above for each couple of a smiley tag and a smiley image, the foreach loop will be ran with the smiley tag put in $tag and the smiley image put in $image. So for example $tag = ‘:)’ and $image = ’smile.jpg’. This is the first variable of our example array ($smilies) – our first couple of a smiley tag ( key ) and a smiley image ( value ).

So let’s put it inside the function.

function replaceSmilies($str, $smilies) {

   foreach($smilies as $tag => $image) {

   }

}

Replacing the smilies

So what will it need to do with this smiley tag and smiley image? It will need to replace the smiley tag by the smiley image inside the string which is set in $str ( see the function argruments & the example $str message set in the beginning ).
Before we’ll do this we’ll first create a new variable ‘$new_str’ which we’ll set equal to ‘$str’ in the first place but which will change as the smiley tags get replaced by the smiley images in there.

function replaceSmilies($str, $smilies) {

   $new_str = $str; //set the new string equal to the string given in the first place
                        //the foreach loop will be replacing the smilies inside this string
                       //so $new_str will contain the new string with images of the smilies (icons) inside

   foreach($smilies as $tag => $image) {

   }

}

Now we’ll be replacing the smiley tags by the smiley images. This will be done inside the foreach loop as there we got the smiley tags inside $tag and smiley images inside $images so we can easily replace them. Therefore we’ll use the str_replace function. So how does this function work?

str_replace("thing to replace", "value to replace it by", "string to do this inside");

so in our case;

str_replace($tag, $image, $new_str);

Which will replace $tag by $image inside $new_str. Which is correct: $tag contains the smiley tag and $image contains the smiley image and $new_str the string to replace these inside ( which will contain the new string ). Now it will return $new_str but then with the smiley tag replaced by the smiley image. But we do want to save this new (replaced) string it returns inside the variable $new_str to update it:

$new_str = str_replace($tag, $image, $new_str);

However now it will replace for example like ‘:)’ by ’smile.jpg’. Which won’t give us the image of ’smile.jpg’ yet!
So instead we need to replace it by:

<img src=’smile.jpg’>

or in general:

<img src=’”.$image.”‘>

So let’s change this inside the replace function:

$new_str = str_replace($tag, "<img src='".$image."'>", $new_str);

And let’s put it inside the loop.

function replaceSmilies($str, $smilies) {

   $new_str = $str; 

   foreach($smilies as $tag => $image) {

     $new_str = str_replace($tag, "<img src='".$image."'>", $new_str);

   }

}

The last thing the function needs to do is return the new string, which is put in $new_str.

function replaceSmilies($str, $smilies) {

   $new_str = $str; 

   foreach($smilies as $tag => $image) {

     $new_str = str_replace($tag, "<img src='".$image."'>", $new_str);

   }

   return $new_str; //return the new, updated string containing the smiley images

}

Smilies Directory Updating

It could be that you’ve put the smiley images inside another map/directory. In that case you can easily update the path of the image inside the loop. Better said: inside the str_replace function of the loop.

To do this, this part needs to be changed:

<img src=’”.$image.”‘>

As that’s the html image that all smileys will be replaced by. And we used a foreach loop for the smileys array which put all smiley images, one per time, inside $image and executed the foreach loop for each smiley the same way. So we only need to change this part as it uses this for each smiley and each smiley image. As they all will be set inside $image and replaced the same way inside the foreach loop.

So, for example, we could update the path like this:

<img src=’yourpath/”.$image.”‘>

     $new_str = str_replace($tag, "<img src='images/".$image."'>", $new_str);

Where we set the path to images/, so all smilies will be replaced by ‘images/smiley_image_name.jpg’ instead of just ’smiley_image_name.jpg’.

Using the function

To use the function we simply call the function and give the string ($str) and smiley tags & images array ($smilies) which we set in the beginning of this tutorial.

<?php

function replaceSmilies($str, $smilies) {

   $new_str = $str; 

   foreach($smilies as $tag => $image) {

     $new_str = str_replace($tag, "<img src='".$image."'>", $new_str);

   }

   return $new_str; //return the new, updated string containing the smiley images

}

$smilies = array(":)" => "smile.jpg", ":P" => "thongue.jpg");
$str = "Hi there!   Example text  ";

echo "Input string: {$str} <p>
          Output string: ".replaceSmilies($str, $smilies);

?>

Download Full Script (function & smilies pack)

I’ve created a sample script of this tutorial which includes a ready to use function for replacing smilies in a text by the smiley images (icons). The smiley icons/images are provided within the zip file and the function automaticly uses these smiley images by default unless you provide another set of smilies to the function.

How to use

<?php

    include("function.php"); //include the smilies function to your file      

    $str = "the message with smilies    "; //setup a variable that contains the message that needs to be converted

    echo replaceSmilies($str); //replace he smilie tags with the default smiley images

    //or: echo replaceSmilies($str, $smilies, $dir); where $smilies is the array with smiley tags & image filenames as done in this tutorial

?>

Download

Method 1
We’ll start with the first method which uses these PHP functions:

* str_split – converts a string into an array
* shuffle – shuffles an array (index and values)

What we need to create first, is a variable $charset which contains all characters and maybe symbols that we want the system to generate a random password out of. So the characters the password generated can/may contain.

Here I take for example all alphabetical characters and all numbers.

<?php

$charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678901234567890012345678901234567890";

?>

The numbers 0-9 I put in it 4 times because there are about 2 times as much alphabetical characters and they’re put inside it twice ( non-capital and capital) and I want to have about the same amount (chance) of characters as numbers inside the password.

What we want to do is create a function that generates a random password using random characters or numbers from our charset. We also need to be able to give the amount of chars to pick randomly out of the charset to create a password from ( the length of the random password ). So the argruments for the function should be: charset, length. Where charset is our $charset and length is the length of the password ( amount of random chars picked from the charset and put together ).

<?php

function random_passw($charset, $length) {

   ... generate $length random chars out of $charset

}

$charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678901234567890012345678901234567890";

$length = 8; //we set the length for our password to 8 chars for example

?>

So now we’ve come to the part of the function which needs to shuffle all characters of the charset. Therefore we first need to put it into an array as the shuffling is based on shuffling the indexes and values. We use the str_split function to put the charset in an array.

function random_passw($charset, $length) {

   $charset_arr = str_split($charset); //charset_array

}

So now the charset is put in an array like this:

$charset_arr[0] = “A”;
$charset_arr[1] = “B”;
$charset_arr[2] = “C”;
… etc …

In this case the index 0 has the value ‘A’. We’ll make a loop which adds that index value to the password ( we’ll make a variable $passw ) the amount of times set in $length:

function random_passw($charset, $length) {

    $charset_arr = str_split($charset); //charset_array

    $passw = ""; //empty password to start with

  for($a=1;$a<=$length;$a++) { //as long as $a is smaller than or equal to $length
  //and increase $a each time the loop is executed

      $passw .= $charset_arr[0]; //add the value of the charset's first character (of index 0, which in this case is equal to the character 'A' )

   }

 }

So now it adds '$length' times the character 'A' to the variable $passw. So if we give the value 8 to the variable $length, it adds 'A' to the password 8 times, like:

$passw = "AAAAAAAA";

But we want it to add a different character to the set (password) each time it adds a character. To do this we use the function shuffle. This function will shuffle all indexes and values randomly - shuffle all chars in the charset in a random order. So say we first got our charset like:

$charset_arr = "ABC";

Which has the array:

$charset_arr[0] = "A";
$charset_arr[1] = "B";
$charset_arr[2] = "C";

It will shuffle all values for the indexes, so it could be shuffled like this then (for example, but it's random so it could be shuffled anyhow) :

$charset_arr[0] = "C";
$charset_arr[1] = "A";
$charset_arr[2] = "B";

So then the index 0 suddenly got the value "C" instead of "A". This way we can make it pick the same index but containing another value for our index '0' each time and this way pick random characters out of the charset.

function random_passw($charset, $length) {

     $charset_arr = str_split($charset); //charset_array

    $passw = ""; //empty password to start with

  for($a=1;$a<=$length;$a++) { //as long as $a is smaller than or equal to $length
  //and increase $a each time the loop is executed

      $shuffled = shuffle($charset_arr); //shuffles the indexes and values - in other words: shuffles the chars in the charset in a random order
      $passw .= $shuffled[0]; //take the value of the index '0' of the SHUFFLED charset - the first character of the shuffled charset which is different each time it's shuffled ( which is each time the loop is executed / shuffle function executed )

      }

  }

Last thing we need to do is make it return the password generated, which can be done using the function return.

function random_passw($charset, $length) {

     $charset_arr = str_split($charset); //charset_array

    $passw = ""; //empty password to start with

  for($a=1;$a<=$length;$a++) { //as long as $a is smaller than or equal to $length
  //and increase $a each time the loop is executed

      $shuffled = shuffle($charset_arr); //shuffles the indexes and values - in other words: shuffles the chars in the charset in a random order
      $passw .= $shuffled[0]; //take the value of the index '0' of the SHUFFLED charset - the first character of the shuffled charset which is different each time it's shuffled ( which is each time the loop is executed / shuffle function executed )

     }

     return($passw);

  }

And we're done!

Example of use:

function random_passw($charset, $length) {

     $charset_arr = str_split($charset); //charset_array

    $passw = ""; //empty password to start with

  for($a=1;$a<=$length;$a++) { //as long as $a is smaller than or equal to $length
  //and increase $a each time the loop is executed

      $shuffled = shuffle($charset_arr); //shuffles the indexes and values - in other words: shuffles the chars in the charset in a random order
      $passw .= $shuffled[0]; //take the value of the index '0' of the SHUFFLED charset - the first character of the shuffled charset which is different each time it's shuffled ( which is each time the loop is executed / shuffle function executed )
  }

  }

$charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678901234567890012345678901234567890";
$length = 8;

$password = random_passw($charset, $length);

echo "Your password is: ".$password;

?>

Method 2

Functions used:

* mt_rand($first, $last) - generates random number between $first and $last
* length($str) - calculates the length of the string $str

What we basicly did in the first method was adding the same index's value of the charset. But we made it contain another value each time by suffling the values of the indexes. Now we'll keep our charset in the same 'order' ( so each index keeps the same value ). But this time we'll change the index we request the value of each time we do so. So this way it requests another index's value ( and so another character ) each time we add a new character to the password. In other words: we add random characters to the password. We'll again use our charset and length variables:

<?php

$charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678901234567890012345678901234567890";

$length = 8; //we set the length for our password to 8 chars for example

?>

And now create a function which generates the random characters. We'll therefore again use a for loop to make it add a new random character to the password string as many times as set in $length. So the password will be the length of $length.

function random_passw($charset, $length) {

   $passw = "";

   for($a=1;$a<=$length;$a++) {

       //add a random character to the $passw

   }

}

We again use the same loop and set a variable $passw in the beginning to empty. We'll be adding the random characters to it inside the for loop. The charset is now already having indexes and values for each character, like this:

$charset[0] = "A";
$charset[1] = "B";
$charset[2] = "C";
... etc ...

Just because we got the characters in this order inside the variable:

$charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz012345678901234567890012345678901234567890";

You see the first character 'A' has been given the index 0. Now what we basicly need to do for adding a random character, is generating a random index for the array ( and so a random value/character corresponding to that index ). Which is generating a random number from 0 ( the first index ) to the last index. The last index can be generated by counting the amount of characters minus 1. Because the first character hasn't been given the index 1 but 0, and for the second character it's 1, etc.. So for the last character's index it's the amount of characters minus one. The amount of characters can be calculated using the length function:

function random_passw($charset, $length) {

   $passw = "";

   for($a=1;$a<=$length;$a++) {

       $first_index = 0;
       $last_index = length($charset)-1;

   }

}

Now we need to generate a random number between the first and last index ( 0 - $last_index ). We can use the function mt_rand to do this.

function random_passw($charset, $length) {

    $passw = "";

    for($a=1;$a<=$length;$a++) {

        $first_index = 0;
       $last_index = length($charset)-1;

       $index = mt_rand($first_index, $last_index); //generates random index

    }

 }

Now we got a random index we generated in the variable $index. And because it's a number between the first and last index of the charset, we are sure it has a value. Which is one of the characters of the charset. Which we can call like $charset[index] ( as it's $array[index], and the charset can be seen a special kind of array where each index has one value ( the next character in the string ) ). And as the random index we generated is in the variable $index, it becomes $charset[$index] for us.So we'll add that value to the password:

 function random_passw($charset, $length) {

     $passw = "";

     for($a=1;$a<=$length;$a++) {

         $first_index = 0;
         $last_index = length($charset)-1;

       $index = mt_rand($first_index, $last_index); //generates random index

       $passw .= $charset[$index];

     }

  }
 

Allright, so now it adds a value of a random index ( and so a random character of the charset ) to the $passw variable. And it does this $length many times. In other words: it creates a random pasword with the length of $length.

Now the last thing to do is actually returning the password:

  function random_passw($charset, $length) {

      $passw = "";

      for($a=1;$a<=$length;$a++) {

          $first_index = 0;
         $last_index = length($charset)-1;

        $index = mt_rand($first_index, $last_index); //generates random index

       $passw .= $charset[$index];

      }

   return($passw);

   }
  

Which is, easy as it gets, the function return. And the random password generator function is done!
It has the same use as the previous one explained in method 1, so enjoy!

Cheers,
Admin.

Btw, realised the first method wasn't that much faster afterall lol