Editors and IDEs help!

Last time, we saw about indentation. Basically, indentation is making specific lines of code offset a bit so that you know at a glance where they belong. There are two ways of making indentation while programming: one is to use tabs (i.e. the tab key) and one is using multiple-spaces e.g. (press the space key 4 times).

Which one you use depends on you. As long as you stick to the style you choose, you should be alright. Now, if you’re writing code for other people e.g. open-source projects or a company, they may enforce a style on you i.e. you should only use space for e.g. because upstream, some other people have troubles with tabs. At this stage, you shouldn’t worry too much about those. In any case, you can have your Integrated Development Environment (IDE) do the substitution for you for e.g. replace a single press of the Tab key by 4 spaces.

You still remember what an IDE is, right? It’s that program that makes the task of writing other programs easier. Like a word processor for writing programs.

It’s a good idea to use an IDE when writing programs. Which IDE you will use largely depends on which language you are writing in, so we won’t go into the various IDEs that exist. If you write in many languages, or don’t want the hassle of having to install and learn an IDE, you could use so-called “Programmer Notepads”.

I did say you’re fine using Windows’ Notepad program. Actually you are. Only, it is not specially meant for writing programs. It’s just a generic text editor.

These are text editors that have IDE-like functions especially code highlighting, syntax checking, code completion and indentation guidelines for e.g. There are many of those out there, so I’ve listed the 5 most common ones so you have something to start. Just choose one and start typing! The number of features provided will vary from just syntax highlighting to fairly complex things like versioning through plugins. So just get one of those 5 and you should have an easier task at writing code:

1. Notepad++
2. PSPad
3. Programmer’s Notepad
4. Crimson Editor
5. Notepad2

On Linux and other Unix variants, you will have the all-powerful Vim and Emacs, as well as GUI variants such as Kate and GEdit. Am just listing those here for reference, but if you’re already on Linux, you should probably already have found those. They probably come ready installed with your OS anyway so just find where they are and start using them.

Which editor you choose doesn’t really matter as long as it does what you want, and it makes things simple. If your editor makes a simple task more complex, you should either consider using another editor or see whether you’re doing stuff right in the first place! Editors vary in terms of features: some people like editors that does everything from highlighting brackets to sending satellites in space on their own. Others just want a place to type and if it provides pretty colors, fine! See what you want in an editor and choose appropriately.

At first, it’s good to try a lot of them to see which one you like. But after a while, try to choose one and learn how it works. You don’t want to keep switching editors mid-project and having to re-learn where the various options e.g. search and replace are found. I.e. find one and love it.

When you’re using one of these editors, the task of checking indentation, finding where brackets and braces open and close etc are handled automatically. That’s one less thing to worry about. But you still need to ensure your indentation is correct. Let’s see how pseudo code would look in one of these editors: Notepad++.

And here’s how it looks in plain old Notepad:

You can see a few things are different from the Notepad++ image. First, the “reserved” or keywords are highlighted in a different color: blue. Second, brackets are highlighted so you can easily identify where pairs of brackets start and end (they are bolded here). Quoted text is in a different color, so if you accidentally missed a quote, you’d see everything in grey and you know something is off. See the faint dotted lines below “If”? They represent indentation guides. That is, they show where the “If” is going to end and what code falls under the control of the If. Similarly, if I had different levels of indentation, I’d see additional lines.  Finally, you can see line numbers. If you’re writing code and a friend says there’s a problem on line 13028, you don’t have to start counting but can go directly to it! Notepad cannot do this for you.

All these little things really help when you are writing large programs with thousands of lines. You can immediately see where a block starts or ends without having to do a ton of scrolling.

I think you’ve got the point now. Use an editor or an IDE. It makes life easier!

Comments

What are comments? It’s as the name says, things you write in the code to make it clearer when reading it. They’re like small notes you write in the code itself to describe bits of code that might be difficult to understand at first glance.

Why would you want to type additional things and make things more tiring? Well, comments help. A lot! A LOT! They may not make sense now, but think about reading the same code, but 2 years later. Will you remember then, what that obscure piece of code does? Probably not. If you have put comments there, then yes, you’ll know immediately.

First, don’t write stupid comments. After you start programming, it’s no use commenting every single line of code. That is both senseless and wasting time. Things like (a+b) are obvious to any programmer. What you should be commenting is when you have codes that do special tasks. For e.g.

Does this make sense?

Does it now?

Now you know the importance of comments.

Comments are identified by different symbols in different languages so make sure to use the right symbol, but here is a quick rundown of the most common symbols used to identify comments in code.

Now you how what comments are, i.e. descriptions about code, written in the code itself and identified using special symbols, I advise you to use plenty of these where you think the code is not very clear or easy to understand. You’ll learn what to comment as you start writing more and more code. It then becomes second-nature and you’ll wish every programmer out there commented their code appropriately.

Consistency

Consistency refers to writing code in the same style, every time. This is not always possible as sometimes different projects impose different styles. But whatever style you will choose, stick to it. I.e. be consistent.

For e.g. I like plenty of white space in my code. I find it makes stuff easier to read. The second one is how I’d write this code. The first one could be written by another person who likes compactness and minimalism. Both do the same thing. If it makes sense to them, fine.

But now, if I start arbitrarily switching between the various styles, for e.g. I use different numbers of white-spaces or different styles of opening and closing brackets, it makes things tough for others.

We’ll see more styles of coding in the other parts, especially after we start “Conditions”. It then becomes important that you write in one consistent way instead of as-you-please. Just keep this point in mind at the moment: choose your style and stick to it. Don’t change mid-way because you think brackets are prettier on their own line. You’ll make many other people angry!

That’s it for this rather short part. I hope you found it interesting. As usual, ask your questions using the comments box below and I welcome comments from other programmers if they think I could have written things better or provided more details. See you in the next part!

In the same series:

• Fundamentals of Programming: Part 3 - Style, Indentation and Comments (This post)
• Fundamentals of Programming: Part 2 - Pseudo Code and Batch Jobs
• Fundamentals of Programming: Part 1 - Introduction

This article comes from GeekScribes

Fundamentals of Programming: Part 3 – Style, Indentation and Comments

We’ll start with writing some instructions in pseudo-code. What is pseudo-code? Does it mean pseudo-programming? Yes, sort of.

You want to make sure you understand how to write and understand pseudo-code because that’s what I’ll be using through the rest of this series. They’re easy, English-like statement so don’t worry too much.

Pseudo Code

Pseudo-code refers to instructions written in a structured language. That is, there are specific words to represent specific things. Like commands for e.g. You’ll understand what I mean soon. The good thing about pseudo code is that it is programming language-independent. You can write instructions in pseudo-code then hand your sheet to any programmer and he or she will be able to write a program based on that. Why? Because pseudo-code represents instructions in an independent way. The programmer will then be able to translate those in the language of his/her choice with appropriate syntax.

In short, pseudo-code are step-by-step instructions to solve problems, written in a “strict” way that can then be used as guideline when writing a program.

Algorithms are usually step-by-step instructions to solve a problem. You could say that pseudo-code is  a way to write algorithms. For e.g., some algorithm in mathematics can say, you need to square this, differentiate that. In pseudo-code, you’re just writing the things to do in a structured way. So for the purpose of this article, I’d say they mean the same things. Just step-by-step instructions.

How do programs begin? They start in the mind of a programmer as a series of steps that must be completed to solve a problem. Programmers think in terms of pseudo-code, and then use those to write programming language codes. Sometimes they write these instructions on paper or a whiteboard to make it easier for them, but for simple things, they just do it mentally. It becomes simple enough with some practice.

To get you started, let’s assume you’re telling a friend how to draw a simple house. You need to tell them instructions. What would you be telling him/her? Write down your commands.

If I were to do that, I’d probably write those lines:

Draw a square, each line being 10 cm. (walls)
At the top of the square, draw a triangle, touching the square. (roof)
Inside the square, draw two smaller squares near the top. (windows)
Near the bottom of the square, in the middle, draw a small rectangle. (Doors)

Hopefully, that should give you a decent-looking house drawn like a 5-year old. Congratulations, you just wrote some pseudo-code!

Let’s see another example. We want to have the computer ask the user for two numbers, add those two numbers and then show the result to the user. Simple enough, huh?

This example has 3 sections: an input section (asking the user), a processing section (add numbers) and an output section (show the result). Those 3 steps are the basic things that happen in programs. These 3 things occur in almost all programs, although they may not be very apparent in all programs.

So let’s see how we can write pseudo codes for this problem:

Input 2 numbers, a and b.
Result = a + b.
Output result.

Simple, yes? This is pseudo-code for addition of two numbers. If you look carefully, you will see I used “a” and “b”. These are called variables and we’ll see about those in the next part. Basically, these act as two generic numbers so whatever 2 numbers the user will tell the computer, they will be represented as a and b.

This is a simple set of instructions and a number of things could go wrong in that. It’s also fairly limited in terms of functions. What if you want something else than addition? What about multiplication? Can’t do. Actually, we can. We will do this in the lesson about conditions. What about adding more than two numbers? Can’t do. Oh yes we can, but in loops lesson!

Normally pseudo-code has a fairly strict syntax so that code written by different people. If a person writes “Input 2 numbers” and another “Enter 2 numbers”, it’s still ok. But if a 3rd writes “Shout 2 numbers”… then no. Thus, pseudo-code uses a restricted number of words in English, normally words which you will normally find in other programming languages. For e.g. “input”, “output”, “if”, “else” etc. You’ll learn about those words as we go along.

Batch Jobs

Sometimes, programs don’t ask the user for any inputs. They just take their inputs from some file or from some other place. Batch jobs, or batch programs, are those programs that run without the user having to supply any data during running. Data, as in numbers, text or other information. They run, do their processing and could do some outputs, although not all of them do.

Let’s see about two examples of batch jobs. First example will read a series of numbers from a file and add them all together. If you don’t understand some parts, don’t worry too much. I’ll cover them in next parts. So, here it is:

Open numbers file.

While there are more numbers to read in file

Add number just read to Total.

End

Output Total.

Close File

Here, we didn’t ask the user for inputs. We just get numbers from a file and add them all to a total count then show that to the user. The “inputs” are actually read automatically so the program can run fast, i.e. doesn’t have to wait for the user to supply numbers one by one. Thus we had to tell the computer to open the needed “numbers” file, read off it and finally close it when it’s done.

Note one thing: the “Add number just read to Total” is a bit off-sided as compared to the rest. This is called “indentation” and it makes reading code blocks easier. At a glance, we can know that this line falls under the control of the “While block”.

Which do you prefer in terms of clarity:

While there are more numbers to read in file
Add number just read to Total.
End

Or:

While there are more numbers to read in file

Add number just read to Total.

End

Guess I already know the answer.

Code blocks are important in programming since they normally do different things as the program is running. So seeing what code is running under the control of which blocks is very important and I encourage you to properly indent your code when you are writing inside blocks. You will learn what this particular block of code does if you read the “Loops” part of this series.

Let’s see another example. This time, no inputs, no outputs. Just processing. The “output” is actually writing to a file. We’ll do the same thing as above: read numbers in a file and find their total. But we’ll then write this number in another file.

Open numbers file

While there are more numbers to read in file

Add number just read to Total

End

Open results file

Write Total to results file

Close results file

Close numbers file

This time, we don’t show the user anything. We just read from one file and write to another. Basically, if this program was ran, the user would just see the program start and exit, and nothing else happen. They will have to open the results file to see something had happened.

That’s it for this part. I hope you enjoyed it and learnt something interesting. If you have questions, just ask in the comments below. Again, I ask programmers out there to please provide suggestions and comments. Thank you for reading and see you in Part 3.

In the same series:

• Fundamentals of Programming: Part 3 - Style, Indentation and Comments
• Fundamentals of Programming: Part 2 - Pseudo Code and Batch Jobs (This post)
• Fundamentals of Programming: Part 1 - Introduction

This article comes from GeekScribes

Fundamentals of Programming: Part 2 – Pseudo Code and Batch Jobs

I don’t know how many parts there will be and I don’t know if I’ll have time to write about everything I can think of at the moment.

Here is what I intend to cover. I may add other things afterwards:

1. What is programming? Questions and IDEs
2. Algorithms, Pseudo Code, Batch Jobs
3. Style, Indentation and Comments
4. Variables and Arrays
5. Data Types
6. Conditions
7. Loops
8. Errors and Bugs
9. Functions
10. Classes
11. Libraries and Plugins
12. Syntax and Programming Languages
13. In Real Life

So please stick around and I hope you will enjoy reading my series of posts. Of course, your comments, questions and suggestions are welcome. I’d really like if my programmer friends, contacts and anonymous readers out there would provide some inputs in these posts to help beginners.

Without further delays, let’s start.

What is programming?

That.

Ugh! What are all those brackets?! What are those awful colors! Public WHAT?! My brain is melting!

Keep calm! Breath in. Breath out. Are you alright? Fine. Don’t worry about this at the moment. You’ll understand more as we go along so just be patient. At least, be positive! It’s in English!

Programming is basically giving instructions to a computer so that knows how to accomplish some task. Why would you need that? Well, everything you do on your computer, you’re doing it through programs. You’re currently viewing this page through a program that allows you to view webpages. You are using a program that gives you an environment to run other programs. Everything is a program. You are in the Matrix. Haha.

Well yes, programs are everywhere. And guess what? Each of these programs were written in some programming language. That thing you just saw above? That was a programming language. That’s what is used to make programs. That is, the “Firefox” or “Internet Explorer” or “Safari” or “Chrome” etc you are using to view this page at the moment? It was written in a language that resembles that one above.

Programming is writing programs in some language. There you have it.

Why do we need programming?

Simple! To make your computer understand what to do or what you want it to do. There’s a difference in that and we’ll see about it a bit later.

Computers are generally dumb machines of metal, silicon, plastic and lots of tiny little stuff that beep, light up and do other wonderful things. But they don’t really understand English. They only work with 2 numbers: zeroes and ones.

Programming is you telling it instructions, but you have to tell the instructions in some language the computer understands. If you think you have to write in zeroes and ones, you’d be correct but not completely.

Programming in zeroes and ones was done at the very start. It was hard as hell because, well, do you think something like 01001100 is meaningful to a human? Nope.

Some person thought it would be a good idea to translate some of those codes into meaningful words and have the computer translate this language into its zeroes and ones.

That person hence created a program that converts English words like “if” into computer-meaningful things like 01001100. Nowadays, you write English and your computer figures the rest out for you after you click a few buttons here and there. Then you see your shiny new program running and you’re happy.

This translation process, if you wish to know, is called “compilation”. There’s also “interpretation”. Both are basically translations, but compilation is done all-at-once while interpretation is done as-you-go.

How many languages are there?

Too many. Estimate? Above 4500. Be scared.

Waaait what?! How can I learn all that?!

You’re not supposed to. You’ll probably be fine learning one of them and you can write nice little programs. But why do we need so many languages? That’s because languages are created for specific tasks. For e.g. PHP is used to create dynamic web sites. That is, the web pages react to things you do, instead of being just boring, static, non-changing pages.

Other languages are for other things for e.g. C++ is used when there’s need for high speed of execution i.e. the program should run fast.

So how do I get started?

Well, you could read books on some language you want to learn. But if you don’t understand programming itself, it’s pretty much pointless to do that. Did you learn English by reading Shakespeare? OMG FOR REAL?!

Nah you probably started by learning letters. And made a mess on walls everywhere. Then you learnt words. Swear words I bet. Then you created sentences. Then you wrote your first paragraph etc etc until at the end, you can finally understand English pretty well.

Programming is like that too. You have to start from the start. What is the start? Letters.

Not really. Programming languages are mostly in English. Mostly. There are some truly weird things out there. But yes, mostly English. So you already have a head start. What you need to learn are the words actually. And that’s what this series of posts will try to teach you about.

You’re not expected to be able to write codes at the end of the series. That will probably be for another series some time later. But at the end, I hope you’ll be able to read a program and able to think about how to write your own program.

I’ll make sure to use plenty of examples while writing so you get to know how programmers think when they are confronted with a solution.

Is there any special equipment I need?

Not really. All you need is a working, powered-on computer, keyboard, mouse, screen and an Internet connection. Since you’re here reading this, you’re all fine.

Ironically, you’ll be using programs to write programs. Interesting huh? First programs were actually “written” using punch cards so these were not really programs. Then after a whole lot of troubles and annoyances, we arrived at the languages we use today. Be happy you don’t have to program in binary. Zeroes and Ones, if you didn’t know what binary (2 numbers) means.

Programmers do use a number of tools to facilitate their task. You can use “Notepad”, that simple text-writing program in Windows that nobody likes. Love it, it’s a nice program. If you’re  using Mac or Linux or some other operating system, just find a text editor and use it.

When you become more familiar and get more powerful (HAR!), you’ll want to use more capable tools. We call these “Integrated Development Environments” (IDEs). Fancy term for “big program that allows me to write big programs”. It’s still a sort of Notepad. Just one on steroids.

You don’t need to bother about any of these for the moment, although you may want to check out Notepad since it makes writing the basic codes I’ll show you WAY easier.

Alright, that’s it for part 1, the Introduction. In the next part, we’ll move on to how programs are born. See you! If you have questions and comments, use the form below.

In the same series:

• Fundamentals of Programming: Part 3 - Style, Indentation and Comments
• Fundamentals of Programming: Part 2 - Pseudo Code and Batch Jobs
• Fundamentals of Programming: Part 1 - Introduction (This post)

Sources:

Picture

This article comes from GeekScribes

Fundamentals of Programming: Part 1 – Introduction

This lesson will deal about session ($_SESSION) and cookies ($_COOKIES)…(This kind of cookie has nothing to do with cookies our grand-mother used to cook for us )

SESSIONS:

What are session and how can they be useful?

Sessions in PHP are meant to keep track and store data for a particular user while they browse our site or pages. For example, with a login system, when the user logs in, PHP must have a way to keep track of the user’s status and with this kind of info, we can allow registered user to access private areas and so on. We can also store other data like what time they logged on, and show messages like: “You’ve been here for X minutes”.

When you start a SESSION, a random Session Id is stored in a COOKIE and the default name is PHPSESSID. Yes, even if it’s a SESSION, the value is also stored in a COOKIE an placed on your computer. The advantage of SESSION is, even if the user has cookies disable on his browser, SESSION will still keep track of user info, because, SESSION not only adds PHPSESSID to a cookie, but all values you assign to a SESSION, are also stored in a file on your server.

How do we start a SESSION?

The answer is simple, you just have to add this line on code on top of your page, before any html or php code whatsoever. It HAS to be at the very top, else you can get error messages.

<?php
    session_start();

    //other stuff below
?>

Author’s note : Sometimes, when declaring session_start(), you might get a fancy notice which will drive you crazy. I will tell you about it later in this chapter.

Let’s try something with SESSION. We will declare a SESSION, assign a value to it, and retrieve the value. Code’s below:

<?php
     session_start(); 

     $_SESSION['view'] = 1; // assign value to session
     echo "Pageviews = ". $_SESSION['view']; //retrieving the value
?>

Let’s analyze this,

1) We declared our session on top of everything.
2) we assigned the value of 1 to the SESSION array at position “view”: $_SESSION['view']. We hence called the SESSION, “view”. Yep, $_SESSION is just an array!
3) We echo out the value of the SESSION.

If you run this code, it will print 1. Cool huh?

With this, we can determine how many times a page has been viewed. The code below:

<?php
    session_start();  //declare session

    if(isset($_SESSION['view']))
       $_SESSION['view'] = $_SESSION['view']  + 1;

    else
       $_SESSION['view'] = 1;

   echo 'You viewed this page '. $_SESSION['view'].' times.';
?>   

This one looks a bit different, we added a condition to check the value of our SESSION.

First, if the session is already set (isset()), We just add 1 to it. According to our condition here, if it’s there, lets just increment it, else we default the value to one.

If you try this code, keeps refreshing your page, and you will see the numbers increasing in value as you refresh.

As you already noticed by now, $_SESSION is also an Array.

<?php
   session_start();

   $_SESSION['firstname']   = 'John'; // Assign value to session called firstname. (Hello again, Mr. John!)
   $_SESSION['lastname']    = 'Dingo';
   $_SESSION['age']         = '18';
   $_SESSION['location']    = 'Mauritius';
   $_SESSION['sex']         = 'Male';

   echo '<pre>';
      print_r($_SESSION);
   echo '</pre>';
?>

Try the code above, it will print an array of the $_SESSION we declare, and yes, it will echo ALL the session we declare, including the view $_SESSION from before. But now, why is it echoing out a $_SESSION that we didn’t declare in the script above? Well, remember, SESSION are being stored on a file on your server. The $_SESSION called “view” is still in there and we are looking at a complete Array of all SESSIONS that has been set.

How do we get rid of this view SESSION then?

In order to achieve this, we have to unset the session view. The name says it all because the built-in function we are going to use is called : unset();

Try the code below:

<?php
   session_start();

   $_SESSION['firstname']  = 'John'; // You again, Mr. John?
   $_SESSION['lastname']   = 'Dingo'; //
   $_SESSION['age']        = '18';
   $_SESSION['location']   = 'Mauritius';
   $_SESSION['sex']        = 'Male';

   unset($_SESSION['view']); //gets rid of the view 

   echo '<pre>';
      print_r($_SESSION);
   echo '</pre>';
?>

Refresh your page and TADA! the $_SESSION called view is gone. Now, since $_SESSION is an array. We can use the foreach() loop as well as the for() loop to deal with Multidimensional Arrays.

Let’s experiment. Code below:

<?php
    session_start();

    $_SESSION['msg'] = array(); //We assign our message session as an empty array;

    $_SESSION['msg']['msg_one'] = 'Hello this is message one.';
    $_SESSION['msg']['msg_two'] = 'Hello this is message two.';
    $_SESSION['msg']['msg_three'] = 'Hello this is message three.';

    echo $_SESSION['msg']; // This will only output Array to our browser. So we don't see any values

    echo '<hr />';

    if(is_array($_SESSION['msg'])){
       foreach($_SESSION['msg'] as $myMsg){
          echo $myMsg.'<br />';
       }        
    }

?>

As you can see here, when we  echo $_SESSION['msg'];, it only outputs Array to our browser. We need to access the data in this array. Remember the foreach loop? It comes in handy there, we are iterating over the Array and outputting it’s value. The results will look like this:

Hello this is message one.

Hello this is message two.

Hello this is message three.

You will notice a new little function called is_array(). This is a built-in function that checks if the argument being pass in an array. This function returns true or false, in our case, it will return true since $_SESSION['msg'] was set as an array to begin with.

Sometimes, these built-in functions comes in handy especially when you’re dealing with dynamically generated data.

You can start a session, but you can also destroy a session. Yes, you can. How?

Just by adding session_destroy() in your script.

Note that, when you close all your browsers, the session is automatically destroyed or cleared if you prefer. But some browsers like Mozilla Firefox sometimes asks you if you would like to save data before closing, if you choose yes, then I believe all the SESSIONS are preserved.

Earlier, i told about session_start() generating an ugly PHP Notice. This is true. Even if it’s a built-in function. How come? Well, let me explain something. In your PHP Configuration (php.ini file), there a line which says:

session.auto_start = 0 or session.auto_start = 1

What this means is, when ‘session.auto_start = 1′, PHP has the power to start a session for you automatically, without you having to put session_start() at top of your script and if it is 0, then you will have to add session_start() at top of your script. PHP starting a session automatically for me. Cool huh? Not so quick pals, this can cause some serious damage later. Follow on.

Let’s assume the server your using right now, has session.auto_start set to 1. With this, you might say, ok, PHP is doing it for me, so I won’t bother adding session_start() in my script. But, what if you move your site on another server, and this another server PHP configuration has session.auto_start set to 0? That means your scripts won’t work and you will get some ugly error messages and yes YOU will have to go in your scripts and add session_start() everywhere where your scripts are using session.

Now, since we are good programmers, we must find a way to make our scripts cross-server. Bypassing this problem is actually quite easy. When a session is declared, a session_id is being generated. Remember, I told you that at the beginning of the lesson? In PHP, you can check if a session_id exist. We use the session_id() built-in function. With this, we can make a condition to bypass our problem. Code below:

<?php
   if(!session_id()) { session_start(); }

   $_SESSION['msg'] = array(); //We assign our message session as an empty array;

   $_SESSION['msg']['msg_one'] = 'Hello this is message one.';
   $_SESSION['msg']['msg_two'] = 'Hello this is message two.';
   $_SESSION['msg']['msg_three'] = 'Hello this is message three.';

   echo $_SESSION['msg']; // This will only output Array to our browser. So we don't see any values

   echo '<hr />';

   if(is_array($_SESSION['msg'])){
      foreach($_SESSION['msg'] as $myMsg){
         echo $myMsg.'<br />';
?>

Have a look at the very first line in the code above. The condition says, if there’s no session_id, then we use the session_start. This will get rid of the pain . I strongly advise that you use this method when starting a session. Believe me, it will save you some time later.

That’s it for $_SESSION. Moving on with $_COOKIES.

Cookies

Unlike the cookies we used to eat, this one is a bit tricky and less tasty, and the syntax is different from SESSION. We don’t start a cookie, we SET a cookie. I believe you all know what browser Cookies are. It’s a way to store data on the users computer in small files.

When a website places a cookie on your PC, it’s to determine wether you have been on this site recently. Usually when you login on a website, there’s a checkbox which says “Remember Me”, if you check it, the script will place a cookie on you computer, after two days, when you go to that same site, the script will check if a cookie exist, if it is, you won’t have to login again, you’re already logged in. Cool huh .. The syntax for COOKIE is below:

setcookie(name, value, expire, path, domain, secure); 

name     = the name of the cookie
value    = the value of the cookie
expire   = the amount of time the cookie will remain alive
path     = which path on your server you want the cookie to be accessible
domain   = the domain that the cookie is available
secure   = Indicates that the cookie should only be transmitted over a secure HTTPS connection from the client.

Below is an example of how to work with cookie:

<?php

    if(isset($_COOKIE['username'])){
       echo "You were there recently ".$_COOKIE['username']." Nice to have you back pal";
    }
    else{
       echo "Hi, you're new here. What is you name?";
       setcookie('username','John',time()+3600,'/');
    }

?>

In the code above, we first make a condition to see if a $_COOKIE name ‘username’ was set. If it was, then it means the user was here recently. Else, it’s his first time, so we show him a message stating that his new, and then, we set a cookie using the setcookie function.

We named our cookie username, we gave it a value of John ( In this example, the value can be anything ), then we set the expire time, in our case, the cookie will expire in 1 hour (in seconds, 1 hour = 3600 seconds). The last parameter is the path; I want this cookie to be accessible everywhere on my server. After expiry, it means the cookie is no longer valid. If the user returned after say, 5 hours, he’ll get the message destined to new users. This is useful when you have checkboxes like “Remember me for a day”. Set the expiry of the cookie to one day, and you’re done.

You will notice that I omitted the domain and secure parameter, it is optional.

If you run the code, you will get: Hi, you’re new here. What is you name?… and a cookie will be set.

But if you refresh it again, you will get: You were here recently John. Nice to have you back pal!, since our condition saw a cookie named “check”.

Remember, John is the value of our cookie, that’s why we get his name in th first if statement.

To get an entire $_COOKIE Array, just run the code below:

<?php

   echo '<pre>';
   print_r($_COOKIE);
   echo '</pre>';

?>

You might get a big Array along with a bunch of values, depending on how many sites has a cookie on your PC

Now that we know how to set a cookie, but how do I delete the cookie? Interesting question. Unlike SESSION, a cookie cannot be delete using the unset() function, neither exist a built-in function call destroy_cookie(). You can’t go on deleting files on the user’s machine, can you?

To delete a cookie, you simply set the expire time in the past.:

Code below:

<?php

   if(isset($_COOKIE['username'])){
      setcookie('username','john',time()-3600,'/');
      echo 'Cookie has been deleted.';
   }

   echo '<pre>';
      print_r($_COOKIE);
   echo '</pre>';
?>

In our if statement, have a look at the setcookie function and analyze the parameters, something has changed. Notice the time()-3600 . Before we did time()+3600. But we wanted to erase it, so we defined the time 1 hour in the past. This will get rid of the cookie. Have a look at the Array, you will notice that John isn’t there anymore. He’s gone. Poor guy. He’ll be back, don’t worry.

Cool, we know how to set a cookie. But what about that time() function you keep talking about?

Well, PHP allows you to work with time. The function time() doesn’t actually return something like 19:50:23. Instead,it returns the current time as a UNIX TimeStamp (the number of seconds since January 1 1970 00:00:00 GMT). This is used as a reference time point to know much time elapsed. It’s the computer’s way of asking: “How long has it before you have eaten?”. So you figure out when you last ate, check what time it is now, and do a substraction and say, “5 mins ago”.If you echo time(), you will get something similar to this:

1268422287

Yes,a bunch of numbers. What the hell is that? That’s how a computer knows “Now”. 7 seconds ago would be:

1268422280

I want a good formatted time. Ok, to compensate for the delay of the PHP Lessons, I will show you some examples of how you can format a date and time using the number of seconds return by time(). The time() function, doesn’t take any parameters. In order to get a nice format of the date and time. We should use the date() function in addition with the time() function. Example below:

<?php
   echo 'Current time is : '. date('Y-m-d H:i:s',time()); // outputs Current time is : 2010-03-12 23:35:40
?>

This code will give you the current time. Well, depending on your server, you might get a time 4 hours earlier than that. If that’s the case, to get the current time, you will need to offset your date() function. Example below:

<?php
   echo 'Current time is : '. date('Y-m-d H:i:s',time() + 14400);
?>

You already noticed, we added 14400 with the time() function. Why 14400? Little maths below:

1 minutes           = 60 seconds, So
1 hour              = 60 minutes, So to get the numbers of seconds in 1 hour, we do
1 hour in seconds   = 60 seconds * 60 minutes which = 3600

Now we know 3600 seconds equals 1 hour.
To get an offset of 4 hours, we multiply 3600 by 4. The result is 14400.

Next we add it to our time() function. Isn’t PHP great?

To get a list of available format of date and time, I strongly suggest you visit this link : http://php.net/manual/en/function.date.php.

While i’m at my little ‘compensating for the delay of lesson’, let’s go back in the past where we used to talk about user defined function.

This is a bonus for you.

When we create our own function, we can pass in arguments, as many as we want. What if one day, our function requires unlimited number of arguments? Supposed some numbers are being returned from a database, we want to make some maths or whatever with those numbers, and it so happens we are getting about 1000 rows of numbers. Are we going to write a function that takes 1000 arguments? If you have the time to type all that, then good luck. But instead of typing, let me show you how to create a function of your own, that can take unlimited amounts of args.

<?php
   function unlimitedArgs(){

      $arguments = func_get_args(); // returns an array of arguments passed to the function when calling it

      foreach($arguments as $args){
         return array_sum($args);
      }
   }

   $someArray = array(1,2,3,4,5);

   echo unlimitedArgs($someArray);

?>

Let’s analyze, first, for a beginner, things looks weird, because we are creating a function that doesn’t take any arguments, and yet, when we call that function, we are passing an array as it’s arguments. Have a look at the function, we have this line:

$arguments = func_get_args();

func_get_args() returns an array of any arguments passed to the function even if we didn’t supply it when created the function itself. This way, we can pass as many arguments as we want. In our example, our argument is an array containing numbers. Our function simply iterates over the array of arguments created by func_get_args, then we use the array_sum function to sum up all the values in the array. Our result is 15.

array_sum(Array) simply sum all the values in the given array.

Ok, I believe this is it for this lesson. If you didn’t understand the last part, comments are open for questions!

Nice reading.

This article was contributed by Tipa of Mu-Anime

This article comes from GeekScribes

PHP Lessons 9: Session and Cookies

Take a look at www.geekscribes.net, on the right side, we have a search form, when you type in a search keyword and press Enter, the page loads and it fetch every results according to what you typed. Ever wonder how it works? Don’t go any further, today I will show you bring a boring html form to life.

Before I start, if you missed the array tutorials, then please, go to the link below, and read the post, give it a try.. because you’ll need to understand how arrays work in order to understand this lesson fully.

Here’s the link:

http://www.geekscribes.net/blog/2009/08/11/php-lessons-arrays/

So let’s begin.. Server Constants are also called Predefined Variables, which are just arrays in fact. I will list some of them, but today, we’ll have a look at two of them..Below is a list:

$_SERVER:     This grabs almost all information about the server your website resides on.

$_GET:        The HTTP GET variables are in there

$_POST:       HTTP POST Variables (Very useful with forms)

$_FILES:      Used with forms also, but only for upload purposes. LIke uploading files to a server. Think Rapidshare.

$_REQUEST:    HTTP Request variables (We can say it is a mix of $_GET and $_POST.
              But don't rely on it too much. The only way to rely on it is to use the function array_map() ).
              Also, it's a bit unsecured to use this one, so avoid!

$_SESSION:    Session Variables
              (This is a handy built-in function use to store data. Like Username, Password, User Clicks.
              It can be useful, but can be hard to understand).

$_COOKIE:     HTTP Cookies.
              (This is use to store information on your computer. Like which preference you choosed for a website.
              Or if you checked Remember Me when logged in, a cookie is set on your computer.)

We’ll deal with $_SESSION and $_COOKIE in a later lesson, so no worries.

Today, we’ll have a look at $_GET and $_POST..and in order for you to understand, we will use an HTML Form to send a Request to the server.. Now, what is “send Request to the server”? Basically, you are making a request for a resource from the server, or are sending something to it. Whatever you put in a form is sent to the server in a special message (or request). The server can then use this to determine what you want and what to do.

There are two methods of sending requests, namely GET and POST. When you use GET, whatever data to be sent is passed in the URL (or action) if the form, in plain text. Using POST, the data is sent in the background making the transfer invisible to the user. Following logic, you won’t be sending login information via GET since the password would be visible in the address bar in plain text. For this, you’ll use POST. For other uses, such as getting an item’s price, GET is perfectly acceptable.

Note, if no value is specified for the action attribute, it means that the page refers to itself. If the page is “test.php”, it’s as if action was set to “test.php”. Also, if you don’t set a method, by default it’s “GET”. So beware if you’ll be using it to send passwords etc.

<form method="post" action="name.php">
   <label for="name">Type your name</label>
   <input type="text" name="name" />
   <input type="submit" name="submit" value="Output my name" />
</form>

Ok, i won’t go through all this, you should at least have a fair knowlegde of HTML if you are studying PHP, but what I will point out is, the part where it says ” <form method=”post” action=”name.php”> ”

The “method” attribute in the form tag is set to post, which means we are going to use POST ( $_POST for php ) and the page to process the code is the same where our form lives, which is set in the “action” attribute of the form tag, so it’s set to nothing, which means, use the same page as our form, the PHP Code will be in the same page.

Ok, let’s make a test. Fire up your code editor or use the old notepad, and type that in a file, say “test.php”. It HAS to end in .php, not .html or .htm, even if it includes HTML codes. If it doesn’t end in .php, it won’t get pre-processed, and you’ll just see your PHP code in plain text.

<?php

  if(isset($_POST['submit']))
  {
     echo "<pre>";
     print_r($_POST);
     echo "</pre>";
  }

?>

<form method="post" action="">
   <label for="name">Type your name</label>
   <input type="text" name="name" />
   <input type="submit" name="submit" value="Output my name" />
</form>

Type in your name in the input box, press enter and see the results.. My output was like this:

Array
(
   [name] => Kevin
   [submit] => Output my name
)

print_r is a function in PHP that allows you to display the contents of an array, in key-value pairs. Here, we are printing the $_POST array. I did say these are just arrays with form data stored in them.

The output therefore means:

Name: is the name of the field in our form. The text-box was called “name”
Submit: is the name of the submit button ( Note: We can get rid of it from our array)

Note that “Output my name” is given as the value for submit. The value attribute of a submit input type is what’s displayed on the button in HTML.

Now that we know what’s stored in our POST Array, we can easily output it. We can acess it through the $_POST array. Like below:

<?php

  if(isset($_POST['submit']))
  {
     echo "My name is ". $_POST['name'];
  }

?>

<form method="post" action="">
   <label for="name">Type your name</label>
   <input type="text" name="name" />
   <input type="submit" name="submit" value="Output my name" />
</form>

So the code first check if the form has been submited:

if(isset ($_POST['submit']) )

If the array key named “submit” has a value (any value) set, then process the codes inside of the IF statement.

$_POST['name'], simply because, in our HTML FORM, the input where you typed your name, has the name attribute set to “name”. If you have another field, say, age. You would type $_POST['age'] to access it.

It’s all about arrays. You can also interact with it using a foreach loop. Most array operations in PHP could theoretically be performed on those $_GET, $_POST, … variables.

Now for the $_GET constant, unlike $_POST, the value is sent through the URL.

The form method is set to get instead of post! Try the code below, then look at your URL in the address bar

<?php

  if(isset($_GET['submit']))
  {
     echo "My name is ". $_GET['name'];
  }

?>

<form method="get" action="">
   <label for="name">Type your name</label>
   <input type="text" name="name" />
   <input type="submit" name="submit" value="Output my name" />
</form>

You will notice that your URL is now :

http://localhost/test.php?name=Kevin&submit=Output+my+name

test.php:            This is the page we are using right now
test.php?name=kevin: This is the fun part. The ?name=<name>, is called a Query String, name is the $_GET Variable, and "kevin" is the value assigned to that variable.

The query strings are separated from the domain by a “?” and are separated by ampersands. Spaces are substituted with “+” symbols. Note, there is a maximum length on the URL length, and hence the amount of data that can be sent via GET. So if you have to send a ton of data, use POST.

Another advice is don’t use multi-word names separated by spaces for the “name” attribute of fields. You don’t want to see: “?my+name=John+smith” in the URL. Then in PHP, you’d do $_POST['my_name'] as the space became an underscore. A whole lot of headaches! So don’t do it! For the sake of fellow programmers.

test.php?name=kevin&submit=Output+my+name : the Submit is just the name of the submit button, you shouldn’t care about that too much

IMPORTANT Notice: When using the $_GET Method, NEVER, and I mean NEVER use password field with it. Use $_POST when you form contains password field. Unless of course you want the whole world to see your password is in fact “password” :p

One thing you can try is, use the $_SERVER variable to check what the Actual URL Query string is set to. Try the code below:

<?php
if(isset($_GET['submit']))
  {
     echo "My name is ". $_GET['name'];
     echo "<hr />"; //<hr /> just makes a horizontal rule (line) appear.
     echo "The URL Query String is ". $_SERVER['QUERY_STRING'];
     echo "<hr />";
  }
?>
<form method="get" action="">
   <label for="name">Type your name</label>
   <input type="text" name="name" />
   <input type="submit" name="submit" value="Output my name" />
</form>

You will notice that the URL Query String is set to : name=<name you typed>&submit=Output+my+name. That is, whatever comes after the “?” mark.

If you don’t want the “submit” part to appear in the URL, simply do not set the “name” and “value” attributes. Note, this works for GET only. If you used POST, the form doesn’t work unless ” name=”submit” ” is set.

A bonus: add this just after the last HR tag, you will see what the default $_SERVER Array holds. Code below:

echo "<pre>";
print_r($_SERVER);
echo "</pre>";

You will get something like:

Array
(
   [HTTP_HOST] => localhost
   [HTTP_USER_AGENT] => Mozilla/5.0 (Windows; U; Windows NT 6.1; en-GB; rv:1.9.1.5) Gecko/20091102 Firefox/3.5.5
   [HTTP_ACCEPT] => text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
   [HTTP_ACCEPT_LANGUAGE] => en-gb,en;q=0.5
   [HTTP_ACCEPT_ENCODING] => gzip,deflate
   [HTTP_ACCEPT_CHARSET] => ISO-8859-1,utf-8;q=0.7,*;q=0.7
   [HTTP_KEEP_ALIVE] => 300
   [HTTP_CONNECTION] => keep-alive
   [HTTP_REFERER] => http://localhost/test.php?name=Kevin&submit=Output+my+name

   ... and it continues with other stuff.
)

That ton of details is a lot of details about your server and its current configuration.

Then you can experiment through the Array like:

echo $_SERVER['HTTP_HOST'];

Which will return ‘localhost’, as shown in the $_SERVER Global Array.

Ok, this should get you started.. Now let’s have a look at how we can get rid of the submit name into our $_POST Array. In order to accomplish this, we will use a built-in function of PHP. This is fun. Code below:

<?php

   if(isset($_POST['submit']))
   {
     // we use the array_pop function to get rid of the last element
     // In our case the last element is the submit button
     //Actually, it returns the last element of the array.
     //Since we are not capturing it, it's discarded. The array is shortened by 1 element.

     array_pop($_POST);
     echo "<pre>";
     print_r($_POST);
     echo "</pre>";
     echo $_POST['name'];
   }
?>

<form method="post" action="">
   <label for="name">Type your name</label>
   <input type="text" name="name" />
   <input type="submit" name="submit" value="Output my name" />
</form>

Try the code, and you will see that unlike the previous one, the line “[submit] => Output my name” is gone. That’s how we get rid of it (Note: It will remove the submit button IF it is the last element in the array, if not, use an IF statement with a foreach loop to pull it out). Like below:

<?php

   if(isset($_POST['submit'])){

     foreach($_POST as $key => $post)
     {
        if($key != "submit")
        {
          echo $post;

        }
     }
   }

?>

<form method="post" action="">
   <label for="name">Type your name</label>
   <input type="text" name="name" />
   <input type="submit" name="submit" value="Output my name" />
</form>

If you do a print_r of $_POST, the submit will be there, because we didn’t use a function to pull it from it’s original array,but from every key and it’s value, we check if there is something which isn’t equal to “submit”, the IF statement will get rid of it, then when we echo the temporary variable $post, we get only our name.

Read this post again and again, until you understand how HTML Forms and PHP Works, next time there will be more from Complex Forms. Try fiddling with the $_GET and $_POST arrays and see the effects. You can also set values in $_GET and $_POST though it’s a bit useless. They are arrays after all.

This article was contributed by Tipa of Mu-Anime

This article comes from GeekScribes

PHP Lessons 8: Server Constants and HTML Forms