Webcodez - The database of web programming tutorials » for loop

Basic Shopping Cart System

admin — Sat, 23 Jan 2010 10:50:20 +0000

NOTE: This is a tutorial on creating a basic shopping cart system and giving an idea on how to create the basic functions of a shopping cart system and does not explain the securing of user input or checking whether the added products ‘exist’ as that all depend on what products you offer and so database interactions which are not used in the basic shopping cart system yet as they only explain the basic functions to handle it. Therefore another tutorial will be created for creating an advanced total shopping cart system, as soon as possible.

Tutorial Content

First off, this tutorial is meant for creating a very basic shopping cart system. Not offering a copy-pastable setup script. It will show you how you can create the following functions for your shopping cart system:

* Adding products ( stored into session arrays )

* Removing products

* Empty/Clear shopping cart

* Retrieving all products ( from session )

* Changing amount on products

We’ll just be creating a simple basic shopping cart system now that is cappable of these 4 things. We won’t be using classes, OOP yet, which we’ll be doing in the next tutorial ( Advanced Shopping Cart System ). Having mentioned this all – let’s start.

Shopping Cart System File

Shpping Cart System PHP File and the structure of the session array containing all products of the shopping cart

What I usually start off with is creating the files we’ll be using. Which is only one:

* cart.php

As sessions are an important part of this system we’ll obviously need to set session_start first to be able to use session variables.

File: cart.php

We’ll be using the session $_SESSON['sc'] to store all products into (sc = shoppingcart ). So if it isn’t there yet, we’ll make it an empty array:

isset is a function used to check if the variable or array has been set/defined. We put a ! before it to check if it has NOT been set yet. The array will be of the following structure (2 products for example, first product gets index 0 ( [0] ), second index 1, etc. ):

$_SESSION['sc'] = array(
         [0] => array("ID" => product_id, "amount" => product_amount),
         [1] => array("ID" => product_id, "amount" => product_amount),
         ... etc ... );

So for each new product, an array is added to the array ’sc’, containing the product ID and amount in cart. So for example to add a test product to the shopping cart at start:

 1, "amount" => 10);
?>

Now we added a test product, ID of the product is 1 and the amount we set to 10.

Retrieve Current Products

Retrieve the products that are currently inside the shopping cart

With this info we can already make it retrieve the current products in the shopping cart. We’ll do this using a foreach loop. First however, we’ll need to check if there are any products in it at all, otherwise say it’s empty. We use the function count to count the amount of sub-variables or sub-arrays in this case, for the array $_SESSION['sc']. As each sub-array represents a product, we can tell if there are any products by counting them using the count function. We’ll store that in a variable $products. If it’s a value greater than 0 ( if there are any sub-arrays/products ), retrieve the products:

$products = count($_SESSION['sc']);
if($products > 0) { //if there are more than 0 products in the shopping cart

    //... retrieve products ...

}else{

   echo "Empty";

}

We’re now going to use 2 loops to retrieve the products. The first loop is a for loop which we use to get all products ( which are all sub-arrays ).

for($curr=0;$curr<$products;$curr++) {

}

What the for loop basicly does here is set a variable $curr to 0 ( the first index -> first product of the array ), which represents the product $_SESSION['sc'][0]. Then it executes the loop ( nothing yet inside ) for that product ( which is $_SESSION['sc'][0] in the first loop execution time, but which is always = $_SESSION['sc'][$curr] ). After executing the loop for that product, it checks whether there are any other products by checking if $curr ( the current index ) is smaller than the amount of products. Which is equal to the last index + 1, as the first product starts with the index 0 instead of 1, and counting products start by 1 of course. So if there are any more products, it gets the next one which has the next array index. As the previous index = $curr, the next one is $curr++, which increases the current index by 1.

Ok so now we can handle all products inside this loop. The current product will be $_SESSION['sc'][$curr] as $curr contains the index of the current product. But as each array got it’s own sub-array (containing the ID and Amount) we need to use a forloop. This will get both the ID and Amount values of the products (sub-arrays):

for($curr=0;$curr<$products;$curr++) {

    foreach( $_SESSION['sc'][$curr] as $key => $value ) {

        echo $key.":".$value." 
";

    }

}

We know each product has it’s own index ( $curr ) and as value a sub-array like this:

array(“ID” => prod_id, “amount” => prod_amount)

So what we do is use a foreach loop to get the indexes ( ID and Amount ) of the array/product and the values of them (product id and product amount ). Then we echo them like this:

        echo $key.":".$value." 
";

which outputs:

ID: product id here
amount: product amount here

for each product it found in the for loop.

Let’s put this all together:

 0) { //if there are more than 0 products in the shopping cart

   for($curr=0;$curr<$products;$curr++) {

    foreach( $_SESSION['sc'][$curr] as $key => $value ) {

         echo $key.":".$value." 
";

     }
   }

}else{

   echo "Empty";

}

Now we completed the first function for our shopping cart system: Retrieving all products. 4 more to go!

Function – Add Products

Function to add products to the shopping cart

Let’s start with creating a function to add a product. This shouldn’t be such a big hassle having discusses all of the structure of the shopping cart array and product sub-arrays. What we basicly need to do is add a new sub-array with the index of the last product’s index + 1 and create the sub array with the product ID and amount. We’ll have a look at the code:

    $new = count($_SESSION['sc']);
    $_SESSION['sc'][$new] = array("ID" => $_GET['p'], "amount" => 1);

So $new contains the new array id for the new product. This is equal to the amount of products because, as mentioned before, product 1 has the index 0. So the last product’s index is the amount of products -1, and we just count one plus that and we’d get our new product index. And we all know -1+1 = 0 So we can leave that out and just count the products and use that number as the new index for the new product added.
Then we add the product by creating a sub-array with the id and amount. The ID is here set to $_GET['p'], so cart.php?p=1 would add product id 1 ($_GET['p'] = 1).

Though we could now add one product twice, which would bug the system as there’s also already an amount set inside the product sub-array (ID and Amount is set for each product). So we need to check whether the product isn’t already in the shopping cart array. We can do this with the following for loop:

for($index=0;$index<$products;$index++) {

    if($_GET['p'] == $_SESSION['sc'][$index]['ID']) {

        $index_exists = true;

    }

}

Let’s go through this code. What it basicly does is set a variable $index to 0 ( the first product’s index ) and execute the loop for each index (product in the shopping cart array), which are the indexes 0 – ($products-1) in other words: $index<$products. Then for each product we need to check if the ID ($_SESSION['sc'][$index]['id']) is equal to the id of the product requested to be added ($_GET['p']). If this is the case for any of the products, $index_exists will be set to true. So when $index_exists is set to true, there was a product found with the ID requested to be added. In that case the product was already added to the shopping cart earlier.

Thus we just need to check if $index_exists is equal to true, if so: the product is already in the shopping cart -> show error message:

if($index_exists) {

    echo "Product already added ";

}else{

    ///... else - product was not added earlier already -> add the product

}

Otherwise ( else ) the product wasn’t found in the shopping cart so it will be added successfully. We can there put our ‘product add’ code:

$new = count($_SESSION['sc']);
$_SESSION['sc'][$new] = array(“ID” => $_GET['p'], “amount” => 1);

if(isset($index_exists)) {

    echo "Product already added ";

}else{

    ///... else - product was not added earlier already -> add the product
    $new = count($_SESSION['sc']);
    $_SESSION['sc'][$new] = array("ID" => $_GET['p'], "amount" => 1);

}

Let’s put that all together again:

 0) { //if there are more than 0 products in the shopping cart

   for($curr=0;$curr<$products;$curr++) {

     foreach( $_SESSION['sc'][$curr] as $key => $value ) {

          echo $key.":".$value." 
";

      }
   }

 }else{

    echo "Empty";

 }

if($_GET['act'] == 'add' AND $_GET['p']) {

for($index=0;$index<$products;$index++) {

    if($_GET['p'] == $_SESSION['sc'][$index]['id']) {

        $index_exists = true;

    }

}

if(isset($index_exists)) {

     echo "Product already added ";

 }else{

     ///... else - product was not added earlier already -> add the product
    $new = count($_SESSION['sc']);
      $_SESSION['sc'][$new] = array("id" => $_GET['p'], "amount" => 1);

 }

}

?>

We used an if loop which checks if $_GET['act'] == ‘add’ and $_GET['p'] exists, which is the case when you go to the url like ‘cart.php?act=add&p=product_id’. So when you link the user there, the product_id will be added to the shoppingcart.

Example link:

Add product #1

Function – Clear Shopping Cart

Function to clear the shopping cart

Allright, now we’ll create a function to clear the shopping cart. Which just unsets the whole session ’sc’:

if($_GET['act'] == 'clear') {

   unset($_SESSION['sc']);

}

We use the function unset to unset the session shopping cart. We’ll do this when the user requests the url cart.php?act=clear, as in that case the GET variable ‘act’ has = ‘clear’ ($_GET['act'] = ‘clear’). Which it checks in the if loop. So you can make a link to that url to make it clear the shopping cart. Like:

Empty Shopping Cart

Function – Update Products

Function to update the amount of each product of the shopping cart

Allright, now we’ve came to the last function which is to change the amount of a product. Which is just changing the sub-variable ‘amount’ of the array $_SESSION['sc'][product_array_id]. For example:

$_SESSION['sc'][0]['amount'] = 10;
//changes the product with array index 0 - sets the amount sub-variable of the product to 10.

We’ll need a form to make the user fill in an amount for a product. For each product we’ll need to make this form ( so the user can added the amount for each product ). So we’ll need to add this form inside the loop where it retrieves all products in the shopping cart. Which was the following code ( remember? ) :

   for($curr=0;$curr<$products;$curr++) {

      foreach( $_SESSION['sc'][$curr] as $key => $value ) {

           echo $key.":".$value." 
";

       }

   }

Which we created in the beginning of the tutorial. We’re going to add this form to it:

    echo "
Change amount: 

";

Let’s have a look at that form. It uses the method POST, which means it puts all user input into $_POST['form_field_name'] variables when the form is submitted. It goes to the page ‘cart.php?aid=”.$curr.”‘ which means it creates the GET variable $_GET['aid'] and sets it equal to $curr, which contains the array index of the current product that’s been updated/changed the amount of. Then we’ve got one field named ‘amount’ which has the value of $_SESSION['sc'][$curr]['amount'], which is the amount of the current product ($_SESSION['sc'][$curr] is the current product sub-array containing amount and ID index, we take the ['amount'] sub-variable).

Put it together:

   for($curr=0;$curr<$products;$curr++) {

       foreach( $_SESSION['sc'][$curr] as $key => $value ) {

            echo $key.":".$value." 
";

        }

    echo "
Change amount: 

";

     }

Let’s update the old for loop and put it all together:

  0) { //if there are more than 0 products in the shopping cart

####UPDATED####

    for($curr=0;$curr<$products;$curr++) {

        foreach( $_SESSION['sc'][$curr] as $key => $value ) {

             echo $key.":".$value." 
";

         }

    echo "
 Change amount: 
 
 ";

      }

  }else{

     echo "Empty";

  }

if($_GET['act'] == 'add' AND $_GET['p']) {

for($index=0;$index<$products;$index++) {

     if($_GET['p'] == $_SESSION['sc'][$index]['id']) {

         $index_exists = true;

     }

 }

if(isset($index_exists)) {

      echo "Product already added ";

  }else{

      ///... else - product was not added earlier already -> add the product
     $new = count($_SESSION['sc']);
       $_SESSION['sc'][$new] = array("id" => $_GET['p'], "amount" => 1);

  }

}

###########ADDED############

if($_GET['act'] == 'clear') {

   unset($_SESSION['sc']);

}

?>

Ok, so when the user tries to update the amount of a product, the variable $_GET['aid'] will be containing the array index of the product and $_POST['amount'] will contain the user filled in amount in the form field ‘amount’.

To check if the user tried to change the amount of a product, we simply check if $_POST['amount'] exists and if not empty:

if(!empty($_POST['amount'])) {

   //update amount

}

Let’s put the array id ($_GET['aid']) inside a variable $array_id and the amount the user filled in for that product ($_POST['amount']) inside a variable $amount:

    $array_id = $_GET['aid'];

    $amount = $_POST['amount'];

Now we need to change the amount of the product with the index $array_id. As all products are in the array $_SESSION['sc'], the product is $_SESSION['sc'][$array_id]. And to change the amount of that product we need to change the sub-variable ‘amount’. So it becomes: $_SESSION['sc'][$array_id]['amount'].
We’ll set it equal to the user input = $amount, so:

if(!empty($_POST['amount'])) {

   //update amount

    $array_id = $_GET['aid'];

     $amount = $_POST['amount'];

    $_SESSION['sc'][$array_id]['amount'] = $amount;

}

Shopping Cart System – End Result

We put it all together and we’re done with our “basic ” shopping cart system!

File: cart.php

   0) { //if there are more than 0 products in the shopping cart

   for($curr=0;$curr<$products;$curr++) {

    foreach( $_SESSION['sc'][$curr] as $key => $value ) {

        echo $key.":".$value." 
";

    }

    echo "
Change amount: 

";

   }

}else{

   echo "Empty";

}

###########ADD FUNCTION############
if($_GET['act'] == 'add' AND $_GET['p']) {

for($index=0;$index<$products;$index++) {

    if($_GET['p'] == $_SESSION['sc'][$index]['ID']) {

        $index_exists = true;

    }

}

if($index_exists) {

    echo "Product already added ";

}else{

    ///... else - product was not added earlier already -> add the product
    $new = count($_SESSION['sc']);
    $_SESSION['sc'][$new] = array("ID" => $_GET['p'], "amount" => 1);
    echo "".$_GET['p']." ID added for index ".$new."";

}

}

###########CLEAR FUNCTION############

if($_GET['act'] == 'clear') {

   unset($_SESSION['sc']);

}

###########ADDED - UPDATE FUNCTION############

if(!empty($_POST['amount'])) {

   //update amount

    $array_id = $_GET['aid'];

    $amount = $_POST['amount'];

    echo "array id:".$array_id." and amount: ".$amount." and product id: ".$_SESSION['sc'][$array_id]['ID']."";

    $_SESSION['sc'][$array_id]['amount'] = $amount;
    echo $_SESSION['sc'][$array_id]['amount'];

}

?>

This system was more complicated to explain because of the arrays and sub-arrays and because of it’s somewhat longer size ( script ). But hope you learnt something!

Cheers,
Admin.

Generate Random Passwords

admin — Thu, 21 Jan 2010 15:04:23 +0000

For generating passwords multiple methods can be used. In this tutorial we’ll be discussing 2 ways to generate random passwords. The result of both methods is exactly the same. Although method 1 is based on generating random indexes and picking another (random) index’s value each time when adding a new random character to the random password. While method 2 is based on picking the same index but shuffling the values and indexes so that that index contains a different value each time.

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.

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 ).

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:

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

For Loop

admin — Sat, 16 Jan 2010 09:54:35 +0000

Then we’ve got the for loop. This loop is in some point of view kind of smilar to the while loop as it as well repeats a certain code several times. Though, the for loop requires a variable to be set, an increment value (or decrement) and a condition, as argruments of the loop. A basic example of a for loop looks like this (structure) :

for ( set variable; condition; action increment/decrement ) {

            ...act code...

}

Say we want to set a begin value (we use the variable named $i, which is a common name for integer variables to be used) to 0 and we want to let it count to 10.

Example:

for ( $i = 0; $i <= 10; $i++ ) {

            echo $i;

}

The variable set is $i, which we set to 0. The condition for the code to be ran is that $i is smaller than or equal to 10. So as long as this is the case, the value of $i will be shown on the screen (echo $i). Each time it shows $i on the screen, $i will be increased by 1 ($i++) and the loop will be repeated as long as the condition ($i<=10) is still true. In other words: it shows the value of $i on the screen, increases it by 1, shows it on the screen again, etc., and repeats this until $i is equal to 10.

Output:

1
2
3
4
5
6
7
8
9
10

You could also make it count downwards:

for ( $i = 10; $i => 0; $i--) {

            echo $i;

}

You see we now set $i (begin value) to 10 and set the condition to $i is larger or equal to 0, and the action to repeat each time the loop is executed to $i--(which means: decrease $i by 1).

Admin.