This article tells you how to pass variables to a PHP page using the query string, and how to access them from that page.

Introduction

Have you ever seen a URL which looked like "www.example.com/page.php?mode=1&style=red"? Well, this page is being passed variables and their values through the query string, here the variables "mode" and "style" are being passed, with values "1" and "red" respectively. The question mark indicates the start of the query string and the ampersand, &, symbol seperates variable=value assignments. The page is then able to read these variables and react according to them, for example to display them to the user.

Passing a query string to a page

There are two ways to pass a QueryString to a page, the first is to enter it manually, for example:

<a href="page.php?mode=1">Mode 1</a>

The above HTML creates a link to a page passing the variable mode with the value "1".

An alternative, and perhaps more useful, way is to use HTML forms. The main thing to remember with forms is that you need to use the GET method to send information via the query string, for example:

<form method="GET" action="page.php">
Please enter your name: <input type="text" name="username" />
<input type="submit" value="submit" />
</form>

This code displays a simple HTML form with a text box and a submit button. When the user enters their name and presses submit, the information in the name box is passed to a page called "page.php" (specified in the form's action attribute) via the query string. So, if I entered "mooseh" and pressed submit, the form will call page.php?username=mooseh. Remember that "username" was what we entered as the text input's name attribute.

Accessing a query string element in a PHP page

In PHP, all the information passed via the query string is held in the $_GET super global array (prior to PHP version 4.1.0 it was called $HTTP_GET_VARS, but that's now depreciated). To access an item, type $_GET['varName'], where varName is the name of the variable in the query string.
To demonstrate, let's create page.php to process the information from the form above:

<?
if($_GET['username'] == "")
{
    // no username entered
    echo "You did not enter a name.";
}
else
{
    echo "Hello, " . $_GET[’username’];
}
?>

So now, me typing in mooseh and pressing submit will generate the reply "Hello, mooseh".

Listing the contents of $_GET

Should you wish to find out everything that's in the query string, you can do so with the following code which displays the variables next to their values in a table:

<table border="1">
<tr><th>variable</th> <th>value</th></tr>
<?
foreach($_GET as $variable => $value)
{
    echo "<tr><td>" . $variable . "</td>";
    echo "<td>" . $value . "</td>";
}
?>
</table>

Conclusion

This article showed you how to pass information between pages with the query string, and a use which allows you to add some increased interactivity. There are a lot of other uses, for example selecting which section of a site to display based on a variable in the query string, and processing form data.

The full URL to a page comes in three parts: The domain name, the path to the file then the filename, and the query string. For example, take the URL http://www.example.com/example/page.php?name=Bob. The three parts of this are:

1. The domain name: www.example.com
2. The path to the page: /example/page.php
3. The query string: name=Bob

So how do you find it all out with your own PHP scripts?

All of the information we need is stored in the $_SERVER array, which is accessible from anywhere in your PHP script (and as such is called a superglobal variable), it works like a normal array and the keys we wish to retrieve the values of are 'HTTP_HOST', 'SCRIPT_NAME' and 'QUERY_STRING' for the three different parts of the url. Alternatively, if we don't need to have the path to the page and the query string seperate, we can use 'REQUEST_URI'.

The following code should let you find it:

<?php
// find out the domain:
$domain = $_SERVER['HTTP_HOST'];
// find out the path to the current file:
$path = $_SERVER['SCRIPT_NAME'];
// find out the QueryString:
$queryString = $_SERVER['QUERY_STRING'];
// put it all together:
$url = "http://" . $domain . $path . "?" . $queryString;
echo "The current URL is: " . $url . "
";

// An alternative way is to use REQUEST_URI instead of both
// SCRIPT_NAME and QUERY_STRING, if you don't need them seperate:
$url2 = "http://" . $domain . $_SERVER['REQUEST_URI'];
echo "The alternative way: " . $url2;
?>

Do you want to know the IP address of a visitor? This can be useful for many reasons, such as tracking site usage or blocking access to specific people. Here's how you can find it using PHP.

In a PHP page, within the PHP tags, <?php ... ?>, you can retrieve the IP address of a user through the server variables array, which is contains information about the user and the server environment and is accessible from anywhere in your PHP script. To do this, you use the code $_SERVER['REMOTE_ADDR']. It works like a normal array, where REMOTE_ADDR is the key, and the IP address of the visitor is the value associated with that key.

Display The IP Address

So, if you want to display the IP Address to the user then the following page will suffice:

<?php
echo "Hello! Your IP Address is: " . $_SERVER['REMOTE_ADDR'];
?>

Exploring the $_SERVER array

You might be wondering what other information you can get from $_SERVER, well you can find out with the following script which displays all the variables in it along with their values if set, in a HTML table:

<table border="1">
<tr><th>Variable</th><th>Value</th></tr>
<?
foreach( $_SERVER as $key => $value )
{
echo "<tr><td>" . $key . "</td>";
echo "<td>" . $value . "</td></tr>";
}
?>
</table>

Finally, the following code works harder to find the true IP of the user by checking for proxies:

function userIP()
{
//This returns the True IP of the client calling the requested page
// Checks to see if HTTP_X_FORWARDED_FOR
// has a value then the client is operating via a proxy
$userIP = $_SERVER['HTTP_X_FORWARDED_FOR'];
if($userIP == "")
{
$userIP = $_SERVER['REMOTE_ADDR'];
}
// return the IP we've figured out:
return $userIP;
}

This article will tell you how to write text on an existing PNG image using PHP using PHP's image manipulation functions. The image functions require the GD library to be installed. This article is fairly basic, however some more detail on the basic functions used is included in the article, "write text on a dynamically generated image in PHP"

First, we need the source image. In this example, we're using an image called image.png (with dimension 150x150, though this code will work with any size of image) which is shown below:

This image is going to be kept in the same directory on the webserver as the php file we're using to manipulate it.

Now it's time for PHP code to load the image. We make use of the function imagecreatefrompng() to get the image into PHP to manipulate. This takes the path to the image as a parameter. If the image can't be loaded then we'll tell it to die() and stop interpreting the page, however there are better ways of dealing with this error.

$im = imagecreatefrompng("image.png");
// if there's an error, stop processing the page:
if(!$im)
{
die("");
}

Next, we'll define some colours for use in the image using the imagecolorallocate() function:

$red_background = imagecolorallocate($im, 255, 0, 0);
$black = imagecolorallocate($im, 0, 0, 0);

Now we get the dimensions of the image, using the imagesx() and imagesy(), which take the image resource as a parameter and return the width and height respectively:

// get the width and the height of the image
$width = imagesx($im);
$height = imagesy($im);

The next step is to draw a black rectangle on to the image to ensure that the text we write is visible. This step is optional, as you could write the text directly on to the image.
The coordinate system used in PHP is that the top left of an image is (0,0) and the bottom right is ($width, $height). We're going to draw the rectangle across the bottom 20px of the image, so we pass imagefilledrectangle two sets of coordinates: (0, $height-20) and ($width, $height). The coordinates we're passing - as the 2nd to 4th parameters) tell the method to draw a rectangle from a point on the left hand side, 20 pixels from the bottom, to the very bottom right of the image. The rectangle is then automatically filled black.

// draw a black rectangle across the bottom, say, 20 pixels of the image:
imagefilledrectangle($im, 0, ($height-20) , $width, $height, $black);

Now it's time to write the text on the image. In this example, we will write the text in the middle of the rectangle we just created. First we declare two variables, $font and $text, to store the int representing the system font we're using and the text we're going to write to the image, respectively.

$font = 4; // store the int ID of the system font we're using in $font
$text = "tiposaurus"; // store the text we're going to write in $text

Then we will calculate where the left edge of the text is. This is done by using imagefontwidth() to get the width of the system font we're using (which is fixed width, so all characters have the same width), then multiplying that by the number of characters in the string we're writing. This finds the length of the text in pixels. We then subtract that from the total width of the image and divide by two to find the left position, which we store in the variable $leftTextPos:

// calculate the left position of the text:
$leftTextPos = ( $width - imagefontwidth($font)*strlen($text) )/2;

Now we write the text to the image, using the imagestring() function passing the variables we created earlier as parameters (NB. As height we're using the image height minus 18 pixels, to estimate a decent fit in the box, rather than calculating the height in the same way as width.)

// finally, write the string:
imagestring($im, $font, $leftTextPos, $height-18, $text, $yellow);

Lastly, we send the image to the browser then clear it from memory:

// output the image
// tell the browser what we're sending it
Header('Content-type: image/png');
// output the image as a png
imagepng($im);

That's it! the output image is:

This will be shown in the browser whenever anyone accesses the php page we've just created!

To finish off, here's the code in full:

<?
// load the image from the file specified:
$im = imagecreatefrompng("image.png");
// if there's an error, stop processing the page:
if(!$im)
{
die("");
}

// define some colours to use with the image
$yellow = imagecolorallocate($im, 255, 255, 0);
$black = imagecolorallocate($im, 0, 0, 0);

// get the width and the height of the image
$width = imagesx($im);
$height = imagesy($im);

// draw a black rectangle across the bottom, say, 20 pixels of the image:
imagefilledrectangle($im, 0, ($height-20) , $width, $height, $black);

// now we want to write in the centre of the rectangle:
$font = 4; // store the int ID of the system font we're using in $font
$text = "tiposaurus"; // store the text we're going to write in $text
// calculate the left position of the text:
$leftTextPos = ( $width - imagefontwidth($font)*strlen($text) )/2;
// finally, write the string:
imagestring($im, $font, $leftTextPos, $height-18, $text, $yellow);

// output the image
// tell the browser what we're sending it
Header('Content-type: image/png');
// output the image as a png
imagepng($im);

// tidy up
imagedestroy($im);
?>

The amount of time you get is determined by your employer – it may be in your contract or might just be how your employer treats others with your job.
There are legal minimums though.

• An adult over 18 is entitled to a 20 minute break if they’re working more than 6 hours in a go.
• Those who are between 16 and 18 are entitled to a 30 minute break if they’re working more than 4 and a half hours in one go.

This break must be all in one go, and in the middle of a shift (not at the beginning or the end).

An adult is usually entitled to a break of 11 hours between working days, while for a young worker (someone above school leaving age but aged below 18) this is 12 hours. And an adult is entitled to 24 hours free of work once a week or 48 in a fortnight, while a young worker is entitled to 48 hours a week clear of work.

However, there are exemptions to these rules (for example agriculture workers during a peak time).

As an Argos stockroom assistant, you take the picking ticket as it comes through, take the item off the shelf and send it down the conveyor belt.

Some items can be heavy, but in that case you aren’t expected to lift it on your own – you should ask for help.

You may also have to count stock.

Related Article:

• Questions to prepare for a Retail Interview

Originally called Block & Quayle, which was later shortened to B&Q.

Part of the Kingfisher retailer group, who used to own Woolworths, however they were sold in 2001.

Staff Discounts: 20% at B&Q, 10% at other Kingfisher stores.

Related Article:

• Questions to prepare for a Retail Interview

Got an interview for a shop assistant position at a retailer, such as Tesco or M&S? Hopefully this article will give you some idea of what questions to expect.

Customer service is important, and if you have had retail experience then you may be asked about times you’ve dealt with a difficult customer, or if you haven’t had any experience, you may be asked hypothetical questions about such a scenario.

Some questions to expect:

• Why would you be a good employee?
• Why do you want to work here?
• What do you know about <company>?
• What woud you do if a customer asked you where something was?
  • Take them to it, never just tell them
• What would you do if you suspected someone was stealing?
  • Don’t approach them, keep an eye on them and tell security
• What would you do if you faced a difficult customer?
• What are your ambitions? / Where do you see yourself in 5 years time?
  • Show some ambition, but they won’t want to hire someone that intends to leave soon.
• Have you ever worked as part of a team before? What was your role?
• What would you do if you had a disagreement with someone in your team?
• Is there anything you would like to know about us?

In your answers you should try to appear customer focused, diplomatic and pleasant to work with.

Also remember to ask questions at the end if you get the chance (and you will). Even simple questions about how busy their store is, how many other people work there, and what you’ll be doing are better than asking nothing, however make sure you don’t seem completely ignorant of the company and the position you’re interviewing for.  Good luck.

A first interview for a graduate position with PwC usually lasts 45 minutes to an hour, and takes place at the office you’re applying to with a manager there. It is usually quite a relaxed interview, a bit like a chat, in which they lead a discussion about points on your application form.

You should expect to be asked questions about your courses at university (“What modules did you like?” or “What did they involve?”), as well as any additional experiences and interests outside university.  If there is anything unusual on your application form then be prepared to talk about that.

Other topics you might be asked questions on:

• How you manage your time between university and your other interests.
  •  “Was there ever a time where you weren’t able to do all the work that you had?”
• Employment and voluntary experience – general questions or inquiries about particular details.

There is also a question or two where you are asked to display some knowledge of business or issues in the business stream, for example:

• Is there any business news you’ve read about recently?
• Talk about an issue in Accountancy from the last 5 years. (Audit)
• Do you know of any recent issues or news in VAT/Indirect Tax? (Indirect Tax)

To prepare for these, it’s probably best to read financial newspapers every so often for a period prior to the interview and keep up with any major news. Be able to talk a bit about some recent issues, and be prepared to be asked follow-up questions (for instance if you talk about a takeover bid, “what does company X have to gain from this?”).

This information was prepared from my own experience and that of others. Hopefully this will give a couple of hints to anyone preparing for an interview, but remember that interview practices may change and this list is by no means conclusive.  Good luck.

This tutorial will show you how to rotate an image in your PHP scripts. You'll need to have the GD library installed to be able to use some of the functions we use in this guide, though this is included with most PHP installations so there's a chance you'll have it.

Image rotation in PHP is handled by a function called imagerotate(), which takes three parameters (and optionally a fourth, which deals with transparency and is beyond the scope of this guide). The first is the resource identifier which you obtain when you load the original image within your script, the second is the angle which you want to rotate the image and the third parameter is used when the image isn't going to be rectangular, and specifies the colour with which to fill the uncovered areas of the rotated image to make it into a rectangle (since all image formats require rectangular images).

The first thing we need to do is to load the original image into the script, we do this with a command such as imagecreatefromjpeg("file.jpg") for JPEG images, or imagecreatefrompng("file.png") for PNG images.

// filename of the original image
$fileName = "cow.jpg";
// load the original image from the file
$original = imagecreatefromjpeg($fileName);

In this example, we're using an image called cow.jpg. The method imagecreatefromjpeg() returns a resource identifier which represents that image within the script - we store this in the variable $original. We need to pass this as the first parameter of the imagerotate() method.

The original image we're using is this particularly nice cow:

Now it's time to rotate the image! First we have to decide how many degrees to rotate the image anti-clockwise. Firstly, we'll just roate the image 90 degrees - this means that the resulting image will be rectangular and we won't have to worry about the third parameter.

// degrees to rotate the image (counter clockwise)
$angle = 90.0;
// rotate the image by $angle degrees
$rotated = imagerotate($original, $angle, 0);

We pass the original image identifer - $original - and the angle to rotate by - $angle - into the imagerotate() function. In this special case the third parameter isn't important so we'll just enter 0 (which represents the colour black). This returns an identifier for the new rotated image, which we store in the variable $rotated.

Now it's time to display the image. We first tell the browser the content type (IE what sort of image we're going to display) then use the appropriate command to output the data of the image. We're dealing with JPEG images in this example, so the Content-type is "image/jpeg" and the method to output the image is imagejpeg().

// print the appropriate header type
// this tells the browser we're displaying a jpeg image
header('Content-type: image/jpeg');
// use the imagejpeg() method to display the rotated image
imagejpeg($rotated);

That code tells the browser we're about to display a jpeg image, then we call imagejpeg($rotated) which turns the image identified by $rotated into the a JPEG image for the browser to display. The output of this code is a sideways cow:

Now let's consider the case where you want to rotate an image by an angle such as 45 degrees which requires the imagerotate() method to fill around the rotated image to produce a rectangle. We need to pass an integer as the third parameter to tell the method which colour to fill around the image with. We will do this by specifying the hexidecimal representation of the colour, as is used in HTML. For example, FF0000 is red (each digit is between 0-F; the first two digits represent the red component, the next two are green and the last two are blue) - in HTML we would use #FF0000. To tell PHP that we're using hex to represent the numbers rather than decimal, we must prefix this number by 0x (zero x).

// degrees to rotate the image (counter clockwise)
$angle = 45.0;
// if the resulting image is not rectangular..
// .. what colour will the uncovered bits be?
$bgColour = 0xFF0000; // red
// rotate the image by $angle degrees
$rotated = imagerotate($original, $angle, $bgColour);

The imagerotate() method works as with a 90 degree rotation except fills the outsides with the colour red. The resulting output is:

Other hexidecimal colour codes are:

• 0xFFFFFF - white
• 0x00FF00 - green
• 0x000000 - black

That's it! This tutorial should have helped you to rotate images in PHP.

The full PHP code for the 45 degree example is below:

 // filename of the original image
$fileName = "cow.jpg";

// degrees to rotate the image (counter clockwise)
$angle = 45.0;

// if the resulting image is not rectangular..
// .. what colour will the uncovered bits be?
$bgColour = 0xFFFFFF; // red

// load the original image from the file
$original = imagecreatefromjpeg($fileName);

// rotate the image by $angle degrees
$rotated = imagerotate($original, $angle, $bgColour);

// print the appropriate header type
// this tells the browser we're displaying a jpeg image
header('Content-type: image/jpeg');
// use the imagejpeg() method to display the rotated image
imagejpeg($rotated);
?>