`, etc
532 |
533 | - Will sit next to one another on the same line
534 | - Don't always automatically receive all CSS styles (padding/margin/width/height etc) - this can be confusing!
535 | - Putting block-level elements within an inline element (such as a link) can lead to unexpected results
536 |
537 | Easy to alter with CSS - `display: block` or `display: inline`
538 |
539 | See:
540 |
541 | - [http://www.quirksmode.org/css/display.html](http://www.quirksmode.org/css/display.html)
542 | - [http://learnlayout.com/inline-block.html](http://learnlayout.com/inline-block.html)
543 |
544 |
545 | ### Layout
546 |
547 | The main CSS properties we use for layout are `display`, `float` and `position`
548 |
549 | A great tutorial:
550 |
551 | - [http://learnlayout.com/](http://learnlayout.com/)
552 |
553 |
554 | ### Positioning
555 |
556 | By default, all HTML elements have a CSS position attribute of `static`
557 |
558 | ```
559 | ...
560 |
561 |
562 | ```
563 |
564 | ```
565 | #main,
566 | #sidebar,
567 | #footer {
568 | position: static; /* this is the default value */
569 | }
570 | ```
571 |
572 | These block HTML elements will be on their own line
573 |
574 | Changing the CSS position attribute allows you to set top/bottom/left/right values - relative to the ``, or a parent container that has `position: relative` applied:
575 |
576 | ```
577 | #main {
578 | position: absolute;
579 | left: 10px;
580 | width: 75%;
581 | background: #eee;
582 | }
583 |
584 | #sidebar {
585 | position: absolute;
586 | right: 10px;
587 | width: 20%;
588 | background: #ffd;
589 | }
590 | ```
591 |
592 | A page laid out using `position: absolute` has its limits
593 |
594 | - 'fixed' heights of content
595 | - layout doesn't adapt to the content
596 |
597 | `position` is useful, but not for main page layout
598 |
599 |
600 | ### Floats
601 |
602 | HTML elements can have a float set with CSS - `float: left;` or `float: right;`
603 |
604 | ```
605 | #main {
606 | background: #eee;
607 | float: left;
608 | width: 80%;
609 | }
610 |
611 | #sidebar {
612 | background: #ffd;
613 | float: right;
614 | width: 15%;
615 | }
616 | ```
617 |
618 | A floated element is shifted to the left or right of its container element as far as possible
619 |
620 | If we float another element in the same direction, it will be shifted until its edge reaches the edge of the first floating element
621 |
622 | Unfloated content flows and wraps around floated elements
623 |
624 | Floats are better that positioning for layout - unlike absolutely positioned elements, floated elements remain in the document flow, so can expand with content
625 |
626 | You should (almost) always set widths on floated elements, although elements with inherent widths (e.g. images) don't need a width set
627 |
628 |
629 | #### Controlling floats
630 |
631 | If we want to control how many floated elements appear on a line, we can wrap a div element around the floated content, and set a width:
632 |
633 | ```
634 |
635 |
block 1
636 | ...
637 |
block 10
638 |
1900
85 | 1901
86 | 1902
87 | ```
88 |
89 | - No way to automatically put today's date in to a web page
90 | - No way to automate tasks or generate content
91 | - File includes - the earliest form of server-side scripting (e.g. storing repetitive content in a separate file so you only need to write it once)
92 | - Display specific content only if certain conditions are met
93 | - Process the information entered into an HTML form
94 | - It can send emails
95 | - It can read and write files on the web server
96 | - It can read web pages (sometimes known as screen or data scraping)
97 | - It can interact with other web services through APIs
98 |
99 | etc... hopefully by now you've been convinced by the advantages of using a server-side language
100 |
101 |
102 | ## Fundamentals
103 |
104 | ### Getting started
105 |
106 | PHP code is identified by being placed within specific script tags:
107 |
108 | ```
109 |
114 | ```
115 |
116 | How to start using PHP:
117 |
118 | - Create a new file
119 | - Give it a file extension of .php (e.g. index.php)
120 | - (Or, change an existing file from .html to .php)
121 | - Write some PHP code within the tags
122 | - View the public URL in a browser
123 |
124 | PHP code can be freely interspersed with normal HTML.
125 |
126 | The PHP interpreter on the server reads the instructions and generates HTML that is sent to the browser
127 |
128 | A static HTML file might look like this:
129 |
130 | ```
131 |
132 |
133 |
134 | The day today
135 |
136 |
137 | What day is it today?
138 |
139 |
140 | ```
141 |
142 | Add some PHP:
143 |
144 | ```
145 |
146 |
147 |
148 | The day today
149 |
150 |
151 | What day is it today?
152 |
153 |
156 |
157 |
158 |
159 | ```
160 |
161 | The server will interpret this PHP and generate:
162 |
163 | ```
164 |
165 |
166 |
167 | The day today
168 |
169 |
170 | What day is it today?
171 |
172 | Friday
173 |
174 |
175 |
176 | ```
177 |
178 | Some rules to note immediately:
179 |
180 | - When ending a PHP command, ensure you use a semi-colon to avoid an error (more on this later)
181 | - The `echo` command is used to insert content into the HTML page.
182 | - PHP is case sensitive
183 |
184 |
185 | ### Variables
186 |
187 | ```
188 | $x = 4;
189 | $y = 10;
190 | $z = $x + $y;
191 | echo $z;
192 | // $z === 14
193 | ```
194 |
195 | Using `=` to assign values to a variable
196 |
197 | Using `+` to add two variables together
198 |
199 | Using `===` to check the value of a variable
200 |
201 | ```
202 | $word1 = "hello";
203 | $word2 = "world";
204 | $sentence = $word1 . $word2;
205 | echo $sentence;
206 |
207 | // $sentence === "helloworld"
208 | ```
209 |
210 | ```
211 | $sentence2 = $word1 . " " . $word2;
212 | // $sentence2 === "hello world"
213 | ```
214 | Using `.` to concatenate strings and variables
215 |
216 | ```
217 | $x = 3;
218 | $y = 5;
219 |
220 | $z = $x + $y;
221 | echo $z;
222 | // $z === 8
223 |
224 | $z = $x . $y;
225 | echo $z;
226 | // $z === "35"
227 | ```
228 | Note the difference in using `.` or `+` to concatenate or add variables
229 |
230 |
231 | #### What is a variable?
232 |
233 | A variable is a container, or a reference to something we want the computer to remember (we say to store in memory)
234 |
235 | In the cases we've just seen, it is a number or a string of text
236 |
237 | We can assign a value to a variable, and can change or read its value at any time
238 |
239 | In PHP, all variable names start with the $ symbol.
240 |
241 | What you call the variable isn't important!
242 |
243 | Variable names are case sensitive, and can't contain spaces or hyphens.
244 |
245 | To use mulitple words in a variable name, the convention is either to `$use_underscores_to_seperate`, or `$camelCaseVariableNames`
246 | (try to stick to one convention or the other)
247 |
248 | Be careful when re-using variable names, using the same one twice will overwrite the old value stored in the variable
249 |
250 | PHP will create a new variable (place in its memory) for any name it doesn’t recognize as a previously used variable
251 |
252 | Variables can be used to store different types of data:
253 |
254 | - Integer: `$num = 4;`
255 | - Float: `$number = 3.14;`
256 | - String: `$str = "this is some text!";`
257 | - Boolean: `$something = true;` // or `false`
258 |
259 |
260 | ### Quotes
261 |
262 | Use quotes (single or double) to surround standard text
263 |
264 | Quote marks around strings of text differentiates these strings from program commands like functions - more on this later
265 |
266 | There is a difference between using single-quotes and double-quotes: when a variable name appears in text surrounded by double quotes, its current value is automatically put into the string
267 |
268 | ```
269 | $name = "Pete";
270 | echo "Hello $name";
271 | // "Hello Pete";
272 | ```
273 |
274 |
275 | ### Comments
276 |
277 | Single-line comments which begin with two forward slashes (`//`) or an octothorpe - hash/pound - sign (`#`).
278 |
279 | ```
280 | // one-line comment
281 | # another one-line comment
282 | ```
283 |
284 | Text to the right of these is ignored by the interpreter, until we start a new line.
285 |
286 | Multiline comments use `/*` and `*/` (just like JavaScript and CSS)
287 |
288 | ```
289 | /*
290 | Multi-line
291 | comment
292 | */
293 | ```
294 |
295 |
296 | ### Operators
297 |
298 | These are used in PHP to check or assign a value to variables
299 |
300 | We've seen a few examples already, the rest will come in useful as we continue to learn
301 |
302 | - `=` asign a value to a variable
303 | - `.` concatenate two values
304 | - `+` add two values
305 |
306 |
307 | #### Comparison operators
308 |
309 | - `===` check if something is identical to something else
310 | - `!==` check if something is not identical to something else
311 |
312 | (We tend to use three === more often than two, it also checks the 'type' of the variable and is therefore more precise and so less likely to lead to unexpected errors)
313 |
314 | - `>` check if something is greater than something else
315 | - `<` check if something is less than something else
316 | - `>=` check if something is greater than or equal to something else
317 | - `<=` check if something is less than or equal to something else
318 |
319 |
320 | #### Maths operators
321 |
322 | - `+` add
323 | - `-` subtract
324 | - `*` multiply
325 | - `/` divide
326 |
327 | You can use parentheses to control the order an equation is calculated:
328 |
329 | ```
330 | $total = (($x * $y) + $z) / 3.14
331 | ```
332 |
333 |
334 | ### Arrays
335 |
336 | We use arrays when we want to store a collection of related bits of data
337 |
338 | ```
339 | $planet = "Mercury";
340 | $anotherPlanet = "Venus";
341 | $planet3 = "Earth";
342 | ...
343 | $planetEight = "Neptune";
344 | ```
345 |
346 | This is 'related' information, so we should store it together
347 |
348 | ```
349 | $planets = array(
350 | "Mercury",
351 | "Venus",
352 | "Earth",
353 | "Mars",
354 | "Jupiter",
355 | "Saturn",
356 | "Uranus",
357 | "Neptune"
358 | );
359 | ```
360 |
361 | We can access an item within an array by referring to its 'index'
362 |
363 | ```
364 | echo $planets[2]; // === "Earth"
365 | ```
366 |
367 | Each item within an array behaves like a variable
368 |
369 | Individual array elements are accessed by following the array’s variable name with an index enclosed in square brackets `$stuff[2]`
370 |
371 | Note that indexes start at 0 not 1!
372 |
373 | The function `count()` returns the total number of elements in the array:
374 |
375 | ```
376 | echo count($planets); // === 8
377 | ```
378 |
379 |
380 | #### Associative Arrays
381 |
382 | These are arrays with non-numeric indexes
383 |
384 | ```
385 | $earth = array(
386 | "radius" => 6371,
387 | "distanceFromSun" => 149600000
388 | );
389 | ```
390 |
391 | This means we can refer to an item in the array via its name rather than a numeric index
392 |
393 | ```
394 | echo $earth["radius"]; // === 6371
395 | ```
396 |
397 | Associative arrays are often used when we want to store more complex collections of data
398 |
399 | The value to the left of the `=>` operator is the index, the value to the right is the item's value
400 |
401 |
402 | #### Why we use Arrays
403 |
404 | Arrays are a handy way to store and use information
405 |
406 | When we access data from submitted forms, we often use arrays
407 |
408 | When we access data from databases, we often use arrays
409 |
410 |
411 | ### File includes
412 |
413 | It can be useful to split different parts of a web page up into a number of includable files
414 |
415 | For example, on a typical website the header and footer will be consistent across all pages
416 |
417 | Having these stored in a single importable file means they would only have to be updated in one place in order to update the entire site
418 |
419 | A static HTML file might look like this:
420 |
421 | ```
422 |
423 |
424 |
425 | Lorem ipsum
426 |
427 |
428 |
429 |
430 |
431 | ```
432 |
433 | Our header.php include file might look like this:
434 |
435 | ```
436 |
437 |
438 |
439 | Lorem ipsum
440 |
441 |
442 | ```
443 |
444 | Our footer.php include file might look like this:
445 |
446 | ```
447 |
448 |
449 | ```
450 |
451 | This simplifies all of the pages in the site:
452 |
453 | ```
454 |
455 |
456 | Page content...
457 |
458 |
459 | ```
460 |
461 | To import files into the page, use one of the following PHP functions:
462 |
463 | - `include`
464 | - `include_once`
465 | - `require`
466 | - `require_once`
467 |
468 | `include_once` and `require_once` are used when importing specific functionality you'd only need once in a site, for example database connection details
469 |
470 | `include` and `require` can be used multiple times in a single page, and so are handy when importing repeated functionality (e.g. a 'back-to-top' link) throughout a page
471 |
472 | When trying to import a file with `include` or `include_once`, if the file doesn't exist the server issues a warning and continues.
473 |
474 | When trying to import a file with `require` or `require_once`, if the file doesn't exist the server issues an error and stops.
475 |
476 | (You'll learn to use one of the four options, depending on the requirements of the include)
477 |
478 |
479 | ### Control Structures
480 |
481 | PHP can be used to perform a specific action only when certain conditions are met
482 |
483 | The main types of conditional logic structures are:
484 |
485 | - if/else
486 | - for
487 | - foreach
488 |
489 | (Again, these are common in most programming languages, not just PHP)
490 |
491 |
492 | #### if/else
493 |
494 | Use different logic based on whether a statement is true or false
495 |
496 | ```
497 | $today = date("l");
498 |
499 | if ($today === "Friday") {
500 |
501 | echo "Hooray, it's Friday!";
502 |
503 | } else {
504 |
505 | echo "Is it Friday yet?";
506 |
507 | }
508 | ```
509 |
510 | To use more than one condition you can use:
511 |
512 | - `||` (which means OR)
513 | - `&&` (which means AND)
514 |
515 | We can combine multiple possible if/else with statements "else if"
516 |
517 | ```
518 | $today = date("l");
519 | $hour = date("G");
520 |
521 | if ($today === "Friday" && $hour >= 17) {
522 | echo "Beer o'clock!";
523 | } else if ($today === "Saturday" || $today === "Sunday"
524 | || $hour < 9 || $hour >= 17) {
525 | echo "Time to relax";
526 | } else {
527 | echo "Get back to work!";
528 | }
529 | ```
530 |
531 |
532 | #### for loops
533 |
534 | Allow us to repeat logic until a condition is met:
535 |
536 | ```
537 | for ($counter=1900; $counter <= date("Y"); $counter++) {
538 |
539 | echo " ".$counter." ";
540 |
541 | }
542 | ```
543 |
544 | The result:
545 |
546 | ```
547 | 1900
548 | 1901
549 | ...
550 | 201x
551 | ```
552 |
553 |
554 | #### foreach loops
555 |
556 | Used for iterating (looping) through arrays
557 |
558 | ```
559 | $planets = array("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune");
560 | foreach ($planets as $key => $planet) {
561 | echo " Planet " . $key . " = " . $planet . "
";
562 | }
563 | ```
564 |
565 | The result:
566 |
567 | ```
568 | Planet 0 = Mercury
569 | Planet 1 = Venus
570 | ...
571 | Planet 7 = Neptune
572 | ```
573 |
574 | Starts with the array to iterate through, followed by the keyword `as`, followed by two variables — the first is assigned the index of the element and the second is assigned the value of that index’s element.
575 |
576 | (If only one variable is listed after `as`, it is assigned the value of the array element.)
577 |
578 | In our example, the `foreach` instruction moves through the array `$planets`, assigning each element in turn to the variable `$planet`
579 |
580 |
581 | ### Forms
582 |
583 | Here's a basic HTML form:
584 |
585 | ```
586 |
596 | ```
597 |
598 | There are two important attributes on a form: `action` and `method`:
599 |
600 |
601 | #### Action
602 |
603 | The action attribute for an HTML form element refers to the URL that the form should send its data to when submitted.
604 |
605 | The action attribute can be left blank, in which case the form will send data to the current URL.
606 |
607 | Alternatively, form data can be sent to a different script/URL when the form is submitted.
608 |
609 |
610 | #### Method
611 |
612 | The method attribute has two possible options, GET and POST
613 |
614 | When using a form to GET or POST values, PHP automatically turns the form data into variables, setting it to the value which was entered by the user.
615 |
616 | Depending on whether the form action is set to GET or POST, the values will be available as `$_GET['field-name']` or `$_POST['field-name']`
617 |
618 | Whether you use GET or POST depends on which is more suitable for the current situation.
619 |
620 |
621 | #### GET (appends the values to the URL)
622 |
623 | PROs:
624 |
625 | - useful for URL hacking (the values in the URL are the input names and values separated by ?, & and =)
626 | - useful for bookmarking or adding links
627 |
628 | CONs:
629 |
630 | - Insecure, so shouldn't be used for sensitive data (such as passwords)
631 | - Can only handle a limited amount of data
632 | - Can only be used for simple form data
633 |
634 | #### POST (doesn't append the values to the URL)
635 |
636 | PROs:
637 |
638 | - Can be used to post images
639 | - Can handle more data than a GET request
640 | - Posted content is hidden from the user, so can contain passwords etc
641 |
642 | CONs:
643 |
644 | - Can't be bookmarked or linked to directly
645 | - Can't be updated via the URL
646 |
647 | When the form is submitted, we can access the values that have been entered via PHP
648 |
649 |
650 | ### Errors
651 |
652 | Unlike with HTML, when the server encounters a PHP error it is likely to stop, resulting in no page being generated
653 |
654 | The error messages should be helpful, showing on which line the error occurred, and hopefully a message indicating what went wrong. These messages are often cryptic!
655 |
656 | Errors with PHP are far more common than with HTML/CSS:
657 |
658 | - Syntax errors
659 | - Missing semi-colons at the end of a line
660 | - Not enough (or too many) quotes, parentheses, curly brackets or other punctuation
661 |
662 |
663 | ## Arrays
664 |
665 | ### Working with arrays
666 |
667 | With simple variables like strings and numbers, we can `echo` their value at any point to see what they currently contain:
668 |
669 | ```
670 | $planets = 5;
671 | $planets = $planets + 3;
672 | echo $planets; // 8
673 | ```
674 |
675 | ```
676 | $sentence = "There are " . $planets . " planets";
677 | echo $sentence;
678 | // "There are 8 planets"
679 | ```
680 |
681 | If you try to echo an array, you'll get... `Array`
682 |
683 | ```
684 | $planets = array("Mercury", "Venus", "Earth", "Mars", "Jupiter");
685 | echo $planets; // Array
686 | ```
687 |
688 | We have seen that to loop through every item in an array, you can use `foreach`:
689 |
690 | ```
691 | $planets = array("Mercury", "Venus", "Earth", "Mars", "Jupiter");
692 | foreach ($planets as $planet) {
693 | echo "" . $planet . "
";
694 | }
695 | ```
696 |
697 | Which results in:
698 |
699 | ```
700 | Mercury
701 | Venus
702 | ```
703 |
704 | This is fine when you know the structure of the array, but this isn't always the case
705 |
706 | If you have an array of data that you don't know the structure of, PHP provides an easy way to preview its contents
707 |
708 | To preview the contents of an array, you can use the `print_r()` function
709 |
710 | ```
711 | $planets = array("Mercury", "Venus", "Earth", "Mars", "Jupiter");
712 | print_r($planets);
713 | Array ( [0] => "Mercury" [1] => "Venus" [2] => "Earth" [3] => "Mars" [4] => "Jupiter" )
714 | ```
715 |
716 | This works, but it can be difficult to read
717 |
718 | When using `print_r()` it usually helps to echo this with HTML `` tags surrounding it:
719 |
720 | ```
721 | $planets = array("Mercury", "Venus", "Earth", "Mars", "Jupiter");
722 | echo "";
723 | print_r($planets);
724 | echo " ";
725 | ```
726 |
727 | Which results in:
728 |
729 | ```
730 | Array (
731 | [0] => Mercury
732 | [1] => Venus
733 | [2] => Earth
734 | [3] => Mars
735 | [4] => Jupiter
736 | )
737 | ```
738 |
739 | `print_r()` works well with associative arrays too:
740 |
741 | ```
742 | $earth = array(
743 | "radius" => 6371,
744 | "distanceFromSun" => 149600000
745 | );
746 |
747 | echo "";
748 | print_r($earth);
749 | echo " ";
750 | ```
751 |
752 | Which results in:
753 |
754 | ```
755 | Array (
756 | [radius] => 6371
757 | [distanceFromSun] => 149600000
758 | )
759 | ```
760 |
761 | `print_r()` isn't useful for a final product - you wouldn't want to display information in this way
762 |
763 | But during development it's a handy way to check the current value of an array variable
764 |
765 |
766 | ### Why arrays are useful
767 |
768 | Arrays are a useful way to use/manipulate/filter information
769 |
770 | Later we won't be creating these arrays manually
771 |
772 | Instead we'll be retrieving data from external sources - e.g. from a database
773 |
774 | We won't know what the content of the array is, but we will have an idea of its structure
775 |
776 | When we recieve this data, we need to put it into a format that we can manipulate with PHP
777 |
778 | We will be learning how to extract information from a database and turn it into an array
779 |
780 | If you learn how to use arrays, then you'll know how to use data from various sources, such as a database or an API call from another website
781 |
782 |
783 | ### Multi-dimensional arrays
784 |
785 | Arrays can contain a mixture of different types of content:
786 |
787 | ```
788 | $things = array(1, 5, "hello", 3.14);
789 | foreach ($things as $thing) {
790 | echo "". $thing . " = " . gettype($thing) . "
";
791 | }
792 |
793 | 1 = integer
794 | 5 = integer
795 | hello = string
796 | 3.14 = double
797 | ```
798 |
799 | Using our planetary examples from before, imagine that we would want to store information about each planet as an array
800 |
801 | ```
802 | $mercury => array(
803 | "size" => 0.3,
804 | "distance" => 0.3
805 | );
806 | ```
807 |
808 | ```
809 | $venus => array(
810 | "size" => 0.9,
811 | "distance" => 0.6
812 | );
813 | ```
814 |
815 | The previous example allows us to store information about each planet
816 |
817 | But it doesn't provide an easy way to group together all the planets
818 |
819 | The reason for using arrays is to group together content
820 |
821 | We want to put each of these planetary arrays into a single array
822 |
823 | We can instead contain these in a single array that contains other arrays:
824 |
825 | ```
826 | $planets = array(
827 | "mercury" => array(
828 | "size" => 0.3,
829 | "distance" => 0.3
830 | ),
831 | "venus" => array(
832 | "size" => 0.9,
833 | "distance" => 0.6
834 | ),
835 | "earth" => array(
836 | "size" => 1,
837 | "distance" => 1
838 | )
839 | );
840 | ```
841 |
842 | We call arrays that contain other arrays *multi-dimensional arrays*
843 |
844 | We can access values from within the arrays in the same way as before:
845 |
846 | ```
847 | foreach ($planets as $planetName => $planetData) {
848 | echo "". $planetName . " size = " . $planetData["size"] . "
";
849 | }
850 | ```
851 |
852 | This results in:
853 |
854 | ```
855 | mercury size = 0.3
856 | venus size = 0.9
857 | earth size = 1
858 | ```
859 |
860 | The ability to create multi-dimensional arrays is useful as it allows us to use a more complex information structure
861 |
862 | In most real-world examples, the data you'll be using will be more complex than a simple row of information
863 |
864 | While we're working this out, the `print_r()` function we saw earlier will allow us to preview all of the values in the array
865 |
866 |
867 | #### Nested foreach loops
868 |
869 | One way to access all information within a multi-dimensional array is to use a `foreach` loop within another `foreach` loop
870 |
871 | ```
872 | foreach ($planets as $planetName => $planetData) {
873 | echo "".$planetName." ";
874 |
875 | foreach($planetData as $attribute => $value) {
876 | echo "".$attribute." : ".$value."
";
877 | }
878 | }
879 | ```
880 |
881 | We can manipulate the information in different ways, use different parts in different situations
882 |
883 | For example, we may not want to display all of the detailed information for every item in one long page
884 |
885 | We may just want to summarise each item initially, then if one is selected display the detailed information only for this item
886 |
887 | Let's just output the name of each planet for now:
888 |
889 | ```
890 | foreach($planets as $planetName => $planetData) {
891 | echo ' '.$planetName.' mercury venus earth
946 |
947 | ```
948 |
949 | To add multiple variables via the URL, separate them with an `&`
950 |
951 | Don't forget when you add an `&` in your HTML you should add `&` or it won't validate
952 |
953 | ```
954 |
955 |
956 | ```
957 |
958 | This is a useful way to pass simple variables around between different pages
959 |
960 | Back to our planets example, so far we have a list of links, one for each planet name
961 |
962 | These links append the selected planet name to the URL
963 |
964 | When a planet link has been clicked, `$_GET['planet']` will have a value
965 |
966 | We can use this, combined with a simple if/else statement checking whether the variable has been set, to detect whether to display the overview list or detail view
967 |
968 |
969 | ```
970 |
980 | You have selected planet
981 |
982 | $value) {
986 | echo ''.$key.' : '.$value.'
991 |
994 | Select a planet to see its details...
995 |
996 | $planetData) {
999 | echo ''.$planetName.'
1003 |
1006 | ```
1007 |
1008 |
1009 | ### $_SERVER
1010 |
1011 | This contains useful information related to the server
1012 |
1013 | For example, you can detect the URL of the current page, the file we're currently using, or the user's browser
1014 |
1015 | you can use `print_r()` to see all the possible values of the `$_SERVER` array
1016 |
1017 |
1018 | ## State, sessions and cookies
1019 |
1020 | One important point to note: variables aren't automatically stored or remembered when you move between pages
1021 |
1022 | The `$_POST` array will only be populated on a page after a form submit has occurred
1023 |
1024 | The `$_GET` array will only be populated if a form submit has occurred on the previous page, or if parameters are appended to the URL
1025 |
1026 | In order to save variables between page refreshes, we have to use an alternative technique
1027 |
1028 | HTTP is a "stateless protocol"
1029 |
1030 | This means that every server request is independent - every time you finish requesting a page, the server forgets about you
1031 |
1032 | It doesn't maintain a connection between client and server, there is no way of identifying a sequence of requests as coming from the same user
1033 |
1034 | In order to remain logged in to a site, you need a way to establish credentials across multiple requests
1035 |
1036 | It is possible to transfer information by appending a value to the URL
1037 |
1038 | It can also be added as a hidden fields in a form
1039 |
1040 | In both cases, however, the information is potentially visible at the client end, either in the location bar of the browser or in the source html of the constructed page
1041 |
1042 | A better technique is needed!
1043 |
1044 |
1045 | ### Cookies
1046 |
1047 | Cookies are small pieces of data passed between browser and server as part of the http message header rather than in the document body
1048 |
1049 | They are saved as a file on the client machine
1050 |
1051 | They can be saved for a single browser session (until you close the browser), or for any specified period of time
1052 |
1053 | They can be read and written by PHP and JavaScript
1054 |
1055 | If any cookies exist for the site in question, they are available to the `$_COOKIE` superglobal variable
1056 |
1057 | (JavaScript can access the same cookies by referencing the `document.cookie` object)
1058 |
1059 | Cookies are created in PHP using the built-in function `setcookie()`
1060 |
1061 | If, for example, we wished to hold a supplied username throughout a single browser session, we would use the following commands:
1062 |
1063 | ```
1064 | $username = $_GET['username'];
1065 | setcookie('username', $username);
1066 | ```
1067 |
1068 | This would then be accessible as `$_COOKIE['username']` no matter how many times a user refreshed the page, until the browser was closed.
1069 |
1070 | It is possible to make a cookie last longer than a browser session - you can set your own expiry date:
1071 |
1072 | ```
1073 | // store the cookie for 30 days from today
1074 | setcookie('username', $username, time() + 60*60*24*30)
1075 | ```
1076 |
1077 | ```
1078 | // store the cookie until the eighteenth of July, 2026
1079 | setcookie('username', $username, mktime(0,0,0,7,18,2026));
1080 | ```
1081 |
1082 | The third parameter for the `setcookie()` function takes a numeric value that equates to the time that the cookie should expire
1083 |
1084 | To remove a cookie, just set its date value to a date in the past
1085 |
1086 | ```
1087 | setcookie('username', NULL, -1);
1088 | ```
1089 |
1090 | Commands to set or change cookie values involve writing a document header, so they must occur before any other document content is output
1091 |
1092 | PHP code to set cookies cannot be interspersed with normal HTML, it must be at the top of a page before any HTML is output
1093 |
1094 | (Even a single space at the beginning of a PHP file before the `
1127 | ```
1128 |
1129 | Once a session has been started, we can reference variables using the `$_SESSION` superglobal array
1130 |
1131 | Session variables can be assigned to or retrieved from the `$_SESSION` associative array at any time
1132 |
1133 | ```
1134 | // start the session - must always happen at the top of the page
1135 | session_start();
1136 |
1137 | // (assuming form has been posted, set session variable)
1138 | $_SESSION['username'] = $_POST['username'];
1139 |
1140 | // this is now accessible anywhere we have a session
1141 | echo $_SESSION['username'];
1142 | ```
1143 |
1144 | Once you set a session variable, it will exist until you remove it or end the browser session
1145 |
1146 | To remove a session variable, use `unset()`
1147 |
1148 | ```
1149 | unset($_SESSION['username']);
1150 | ```
1151 |
1152 | Use sessions rather than cookies:
1153 |
1154 | - Session values are stored in temporary files at the server end rather than in the client
1155 | - Therefore sessions are far more secure and reliable than cookies
1156 |
1157 |
1158 | ## PHP and MySQL
1159 |
1160 | ***(It may be worth reading the database notes before continuing)***
1161 |
1162 |
1163 | ### Connecting to a MySQL Database with PHP
1164 |
1165 | To connect to a MySQL database with PHP we use a _class_ called `mysqli`
1166 |
1167 | The line of PHP code we need to do this is:
1168 |
1169 | ```
1170 | $db = new mysqli("host", "username", "password", "database");
1171 | ```
1172 |
1173 | We can create a simple PHP script to test to see if we can connect to the database correctly:
1174 |
1175 | ```
1176 | // connect
1177 | $db = new mysqli("server","u","p","db");
1178 |
1179 | // check if there was an error
1180 | if ($db->connect_error) {
1181 | echo "Connect failed: " . $db->connect_error;
1182 | exit();
1183 |
1184 | // no error!
1185 | } else {
1186 | echo "Database connected!";
1187 | }
1188 | ```
1189 |
1190 | An explanation of the database connection code:
1191 |
1192 | - We're storing the database connection in a variable called `$db` (We'll use this variable again later when we query the database)
1193 | - We test to see if there was an error connecting (for example because of incorrect credentials) by seeing if `$db->connect_error` has a value
1194 | - If there was an error connecting then we display it
1195 | - Otherwise the database connection was successful!
1196 |
1197 | Note that from now on in these examples it is assumed that the database connection is active
1198 |
1199 | It is often a good idea to keep connection details in a separate file for convenience
1200 |
1201 | This file can be imported at the start of every page, using `require_once`
1202 |
1203 | This approach means you only need to update the content for these in one place
1204 |
1205 | (A good practice to get in to!)
1206 |
1207 |
1208 | ### Executing SQL queries with PHP
1209 |
1210 | Once we have established a connection to the database, we can query it with SQL
1211 |
1212 | A basic SQL example is to select everything from the answers table:
1213 |
1214 | ```
1215 | SELECT * FROM `answers`
1216 | ```
1217 |
1218 | This should return the following content:
1219 |
1220 |
1221 | | id | question_id | user_id | answer | tweet_id | date_added |
1222 | |----|-------------|---------|-----------|-------------|---------------------|
1223 | | 1 | 1 | 1 | Edam | 23741876128 | 2013-03-19 18:34:23 |
1224 | | 2 | 2 | 1 | Charles | 23741456214 | 2013-03-21 18:35:51 |
1225 | | 3 | 1 | 2 | Melted | 23723849723 | 2013-03-22 09:02:12 |
1226 |
1227 |
1228 | When we get it into PHP, this data will be represented as an associative array, like those we have seen previously
1229 |
1230 | To execute this with PHP, first we add our SQL query to a variable:
1231 |
1232 | ```
1233 | $query = "SELECT * FROM `answers`";
1234 | ```
1235 |
1236 | Then we execute the query...
1237 |
1238 | ```
1239 | $result = $db->query($query);
1240 | ```
1241 |
1242 | ...and fetch the results
1243 |
1244 | ```
1245 | $row = $result->fetch_assoc();
1246 | ```
1247 |
1248 | This will return us the relevant data in an associative array, stored in the variable `$row`
1249 |
1250 |
1251 | Here is the example code
1252 |
1253 | ```
1254 | // include connection settings
1255 | require_once "../includes/connect.php";
1256 |
1257 | // get a list of all answers in the database
1258 | $query = "SELECT * FROM `answers`";
1259 |
1260 | // perform the query
1261 | $result = $db->query($query);
1262 |
1263 | // loop through the results as an associative array
1264 | while ($row = $result->fetch_assoc()) {
1265 | echo "";
1266 | print_r($row);
1267 | echo " ";
1268 | }
1269 | ```
1270 |
1271 |
1272 | ### while() loops
1273 |
1274 | We want to turn each row in the table into a simple PHP associative array
1275 |
1276 | We're going to deal with each result individually, looping through them one by one
1277 |
1278 | We will use a `while()` loop, which is similar in many ways to the `foreach()` loops that we've seen previously
1279 |
1280 | The while loop will set the variable `$row` to an array containing the values of the current row in the table
1281 |
1282 | The `$row` array keys will be the table column names
1283 |
1284 | The first time the while loop is run, the following values are present
1285 |
1286 | ```
1287 | echo $row['id']; // 1
1288 | echo $row['answer']; // 'Edam'
1289 | echo $row['date_added']; // '2013-03-19 18:34:23'
1290 | ```
1291 |
1292 | When the script reaches the end of the while loop - the closing `}` - it will go back to the start of the while loop, but this time the value of `$row` will be set to the next row in the table
1293 |
1294 | This will continue until it has run through every row that has been returned by the SQL query
1295 |
1296 |
1297 | ### Multiple SQL Queries
1298 |
1299 | It's easy to change the SQL query to update the data we'll receive
1300 |
1301 | In the next example I've just changed the query from the `answers` to `questions` table to get different results
1302 |
1303 | ```
1304 | $question_query = "SELECT * FROM `questions`";
1305 | ```
1306 |
1307 |
1308 | ### SQL Errors
1309 |
1310 | It is a good idea to wrap an if/else conditional statement around the query
1311 |
1312 | This will help to identify any errors with the SQL query
1313 |
1314 | ```
1315 | // get a list of all content from an unknown table
1316 | $query = "SELECT * FROM `lorem_ipsum`";
1317 |
1318 | // perform the query
1319 | if ($result = $db->query($query)) {
1320 |
1321 | // ... display results as before
1322 |
1323 | // if there was an error with your query
1324 | // this will display it
1325 | } else {
1326 | echo "SQL Error: " . $db->error;
1327 | }
1328 | ```
1329 |
1330 |
1331 | ### CRUD
1332 |
1333 | We have SELECT SQL queries working with PHP
1334 |
1335 | We'll come back to these again in a little while
1336 |
1337 | Let's get the other CRUD commands working
1338 |
1339 | - Create = `INSERT`
1340 | - Request = `SELECT`
1341 | - Update = `UPDATE`
1342 | - Delete = `DELETE`
1343 |
1344 | We can also write PHP scripts to create, update and delete data with SQL
1345 |
1346 | These examples use a value called `affected_rows` to test how many rows (if any) they have changed in the database
1347 |
1348 | To check that they have changed the data, we could go back and look at one of the `SELECT` examples again
1349 |
1350 |
1351 | #### INSERT
1352 |
1353 | This SQL command will add a new entry to the `questions` table:
1354 |
1355 | ```
1356 | INSERT INTO
1357 | `questions` (`id`, `question`, `date_added`)
1358 | VALUES
1359 | (3, 'Favourite Fish', 2013-03-25 18:34:13);
1360 | ```
1361 |
1362 | This can be executed by a PHP script in a similar way to the SELECT commands we saw earlier
1363 |
1364 | ```
1365 | // add new question
1366 | $query = "INSERT INTO `questions` (`id`, `question`, `date_added`) VALUES (3, 'Favourite Fish', 2013-03-25 18:34:13);";
1367 |
1368 | // perform the query
1369 | $result = $db->query($query);
1370 | if ($result) {
1371 |
1372 | // output a count of how many rows were changed
1373 | echo "SQL successful, affected rows: " . $db->affected_rows;
1374 |
1375 | // there was an SQL error
1376 | } else {
1377 | echo "SQL Error: " . $db->error;
1378 | }
1379 | ```
1380 |
1381 |
1382 | #### UPDATE
1383 |
1384 | This SQL command will update the question field of the entry we just added to the `questions` table:
1385 |
1386 | ```
1387 | UPDATE `questions` SET `question` = 'Favourite Fruit' WHERE `id` = 3;
1388 | ```
1389 |
1390 | This can be executed by a PHP script in the same way as the INSERT command
1391 |
1392 | ```
1393 | // update question
1394 | $query = "UPDATE `questions` SET `question` = 'Favourite Fruit' WHERE `id` = 3";
1395 |
1396 | // perform the query
1397 | $result = $db->query($query);
1398 | if ($result) {
1399 |
1400 | // output a count of how many rows were changed
1401 | echo "SQL successful, affected rows: " . $db->affected_rows;
1402 |
1403 | // there was an SQL error
1404 | } else {
1405 | echo "SQL Error: " . $db->error;
1406 | }
1407 | ```
1408 |
1409 |
1410 | #### DELETE
1411 |
1412 | This SQL command will delete the question we just added to the `questions` table:
1413 |
1414 | ```
1415 | DELETE FROM `questions` WHERE `id` = 3;
1416 | ```
1417 |
1418 | This can be executed by a PHP script in the same way as the INSERT and UPDATE commands
1419 |
1420 | ```
1421 | // delete question
1422 | $query = "DELETE FROM `questions` WHERE `id` = 3;";
1423 |
1424 | // perform the query
1425 | $result = $db->query($query);
1426 | if ($result) {
1427 |
1428 | // output a count of how many rows were changed
1429 | echo "SQL successful, affected rows: " . $db->affected_rows;
1430 |
1431 | // there was an SQL error
1432 | } else {
1433 | echo "SQL Error: " . $db->error;
1434 | }
1435 | ```
1436 |
1437 |
1438 | ### Displaying results
1439 |
1440 | At this point we have basic SELECT SQL queries working with PHP
1441 |
1442 | For now we're just using `print_r()` to test that we have data in a variable, in a similar way to the examples we saw earlier
1443 |
1444 | This is fine while developing to test that we're receiving data, but you don't want to display content in this way for a live site
1445 |
1446 | We need to learn how to take the SQL query results array we recieve, and display it properly with HTML
1447 |
1448 | Using a while loop to access each row individually:
1449 |
1450 | ```
1451 | // query the database
1452 | $query = "SELECT `id`, `answer`, `date_added` FROM `answers`";
1453 |
1454 | // fetch all results
1455 | $result = $db->query($query);
1456 |
1457 | // loop through each result one at a time
1458 | while ($row = $result->fetch_assoc()) {
1459 | // do something with $row
1460 | }
1461 | ```
1462 |
1463 | The while loop will set the variable `$row` to an array containing the values of the current row in the table
1464 |
1465 | The `$row` array keys will be the table column names
1466 |
1467 | The first time the while loop is run, the following values are present
1468 |
1469 | ```
1470 | echo $row['id']; // 1
1471 | echo $row['answer']; // 'Edam'
1472 | echo $row['date_added']; // '2013-03-19 18:34:23'
1473 | ```
1474 |
1475 | To add these to the HTML:
1476 |
1477 | ```
1478 | // query the database
1479 | $query = "SELECT `id`, `answer`, `date_added` FROM `answers`";
1480 |
1481 | // fetch all results
1482 | $result = $db->query($query);
1483 |
1484 | // loop through each result one at a time
1485 | while ($row = $result->fetch_assoc()) {
1486 | echo '
1487 |
1488 | Answer ' . $row['id'] . ' = ' . $row['answer'] . ' (added on ' . $row['date_added'] . ')
1489 |
1490 | ';
1491 | }
1492 | ```
1493 |
1494 | ### Counting results
1495 |
1496 | You may only want to display results if there are any to display
1497 |
1498 | To do this you can use `num_rows` to count the number of rows that have been returned
1499 |
1500 |
1501 | ```
1502 | $result = $db->query($query);
1503 |
1504 | // check we have a result
1505 | if ($result->num_rows > 0) {
1506 |
1507 | // do something
1508 | echo "There were " . $result->num_rows . " results";
1509 |
1510 | // if there are no results
1511 | } else {
1512 |
1513 | // do something else
1514 | echo "Sorry, there were no results";
1515 |
1516 | }
1517 | ```
1518 |
1519 |
1520 | ### Adjusting queries based on user input
1521 |
1522 | Up to this point we have seen fixed SQL queries
1523 |
1524 | We can use PHP to adjust our SQL queries dynamically by using variables, rather than hard-coding values
1525 |
1526 | For example, we could use an HTML form to allow a user to enter a value, then search our database for this
1527 |
1528 | ```
1529 | $query = "SELECT * FROM `answers` WHERE `answer` LIKE '%" . $_GET['suggestion'] . "%''";
1530 | ```
1531 |
1532 |
1533 | #### Dynamic CRUD queries
1534 |
1535 | We saw earlier some basic examples of other CRUD commands, used to INSERT, UPDATE and DELETE data from the database
1536 |
1537 | We can combine these with HTML forms to make this more dynamic
1538 |
1539 | ```
1540 |
1550 | ```
1551 |
1552 | This form can be used to add new questions:
1553 |
1554 | ```
1555 | // check if form has been posted
1556 | if (!empty($_POST) && !empty($_POST['question'])) {
1557 |
1558 | // create insert SQL query
1559 | $query = "INSERT INTO `questions` (`question`, `date_added`) VALUES ('".$_POST['question']."', NOW())";
1560 |
1561 | $result = $db->query($query);
1562 | ```
1563 |
1564 | There is a problem with this insert form - it doesn't check for existing data before adding a new row to the database
1565 |
1566 | Before adding a new question, it should first check to see if the question code already exists
1567 |
1568 | (This same technique may come in handy when you are thinking about adding users to your website - you shouldn't have two users with the same username)
1569 |
1570 | ```
1571 | // only add to the database if the form has been submitted
1572 | if (!empty($_POST) && !empty($_POST['question'])) {
1573 |
1574 | // save a reference to the question
1575 | $question = $_POST['question'];
1576 |
1577 | // check whether question exists already
1578 | $query = "SELECT COUNT(*) AS `count` FROM `questions` WHERE `question` = '".$question."'";
1579 | $result = $db->query($query);
1580 | $data = $result->fetch_assoc();
1581 |
1582 | // if question exists already, don't add a new one
1583 | if ($data['count'] > 0) {
1584 |
1585 | echo "This question exists already, please add a different one
";
1586 |
1587 | // no question, so add it
1588 | } else {
1589 |
1590 | // insert SQL query
1591 | $query = "INSERT INTO `questions` (`question`, `date_added`) VALUES ('".$question."', NOW())";
1592 |
1593 | // perform the query
1594 | $result = $db->query($query);
1595 |
1596 | // check the query was successful
1597 | if ($result) {
1598 |
1599 | // output a count of how many rows were changed
1600 | echo "SQL successful, affected rows: " . $db->affected_rows . "
";
1601 |
1602 | // there was an SQL error
1603 | } else {
1604 | echo "SQL Error: " . $db->error;
1605 | }
1606 | }
1607 | }
1608 | ```
1609 |
1610 |
1611 | #### Updating and deleting
1612 |
1613 | When updating or deleting data, it often makes sense to turn this into a two-step process
1614 |
1615 | Firstly, the user should be able to select the item to update or delete
1616 |
1617 | Once an item has been selected for updating, we pre-fill the values of a form to make it easier to update
1618 |
1619 | Once an item has been selected for deleting, we offer the user a final chance to change their mind. (Remember there is no undo!)
1620 |
1621 |
1622 | ## Misc. tips
1623 |
1624 | Many of these topics are independent from one another, some may be more relevant or interesting than others...
1625 |
1626 |
1627 | ### Site architecture
1628 |
1629 | When creating a website, it is important to decide on the site structure (or architecture)
1630 |
1631 | - What sections (or pages) will the website have?
1632 | - Will there be sub-sections?
1633 | - Can any user access every part of the site, or do you have to be logged-in in order to access certain aspects?
1634 |
1635 |
1636 | An example page list:
1637 |
1638 | - Home page
1639 | - Item details page
1640 | - User login page
1641 | - User registration page
1642 | - Add an item page
1643 | - (etc)
1644 |
1645 | Once you've decided on the site architecture you can put the file structure together in a logical manner
1646 |
1647 | You could create a PHP file for every page in the site
1648 |
1649 | You could either have these all in the same folder, and name them differently:
1650 |
1651 | - index.php
1652 | - details.php
1653 | - login.php
1654 | - register.php
1655 | - add.php
1656 |
1657 | Or you could call them all index.php and put them into directories:
1658 |
1659 | - /index.php
1660 | - /details/index.php
1661 | - /login/index.php
1662 | - /register/index.php
1663 | - /add/index.php
1664 |
1665 | The advantage of the second approach is that you don't need to reference the file name, which makes your URLs look cleaner
1666 |
1667 | - http://url.com/details.php
1668 | - http://url.com/register.php
1669 |
1670 | vs.
1671 |
1672 | - http://url.com/details/
1673 | - http://url.com/register/
1674 |
1675 | (subjective opinion!)
1676 |
1677 | Consider creating an includes (or assets) directory for any files that aren't displayed directly in a browser
1678 |
1679 | Examples of files that could go into this directory are:
1680 |
1681 | - a CSS file
1682 | - a folder to contain images
1683 | - a JavaScript file (or a folder containing JavaScript files)
1684 | - PHP include files
1685 | - database connection include file
1686 | - header and footer include files
1687 |
1688 | Consider separating functionality into files:
1689 |
1690 | - You may find yourself adding the same functionality in numerous files
1691 | - Any time you repeat the same code, remember there is probably a more efficient way to do it
1692 |
1693 | Consider putting this code into a separate file and including it every time you need it (as we have done with the db connection, header, footer)
1694 |
1695 | - You could put your session-handling logic into one file that you include at the top of every page
1696 | - You could put your database calls into a separate file to keep them together
1697 | - Additionally, you could then use functions to reference each one as and when you need it (We'll look at functions a little later on)
1698 |
1699 |
1700 | ### Header include files and page titles
1701 |
1702 | We've seen examples of header and footer include files:
1703 |
1704 | ```
1705 |
1706 |
1707 |
1708 |
1709 |
1710 | ```
1711 |
1712 | In the previous example, the same title was used for every page
1713 |
1714 | To set a different page title for each page, you could set a variable above the header include:
1715 |
1716 | ```
1717 |
1721 | ```
1722 |
1723 | The `$title` variable would then be available to echo in the header.php file, meaning you could output a different title on every page
1724 |
1725 |
1726 | ### Functions
1727 |
1728 | Functions are a way to group together a set of commands so that we can re-use them whenever we need to
1729 |
1730 | Functions are useful because you can write them once, then use them wherever and whenever you need
1731 |
1732 | There are two types of function:
1733 |
1734 | - Those that are native (built-in) to the language already
1735 | - Functions that we write ourselves - or alternatively 'third-party' functions that someone else has written that we can include and use
1736 |
1737 |
1738 | #### Native functions
1739 |
1740 | There are lots of built-in functions in PHP which allow us to easily perform a specific task. For example:
1741 |
1742 | - `date()` - Get the current date/time
1743 | - `mail()` - Send an email
1744 | - `scandir()` - List all files and folders in a specific directory on the web server
1745 |
1746 | There is a comprehensive list at [php.net](http://php.net) - using the search box is a good place to start
1747 |
1748 |
1749 | #### Third-party functions
1750 |
1751 | Third-party functions are useful when you want to do something that has probably be done many times before
1752 |
1753 | Often you can find that someone else has created a solution and put their example online
1754 |
1755 | Websites like stack overflow, are good places to look for these
1756 |
1757 | Code libraries and frameworks often contain a number of useful functions - more on that later...
1758 |
1759 |
1760 | #### Writing functions
1761 |
1762 | Creating our own functions is a useful way to reduce code repetition
1763 |
1764 | If you find yourself writing the same code several times, it could be made more efficient by creating a function
1765 |
1766 | ```
1767 | function doSomething() {
1768 | // code
1769 | }
1770 | ```
1771 |
1772 | As you build a website, you may start to notice situations where a function could help
1773 |
1774 | How you define a function:
1775 |
1776 | ```
1777 | function name() {
1778 | // do something
1779 | }
1780 | ```
1781 |
1782 | Then, to call this function at any time:
1783 |
1784 | ```
1785 | name();
1786 | ```
1787 |
1788 | Here's a function to output a link we may use lots of times
1789 |
1790 | ```
1791 | // output a back to top HTML link
1792 | function backToTop() {
1793 | echo '
1794 | Back to top
1795 | ';
1796 | }
1797 | ```
1798 |
1799 | To use this function:
1800 |
1801 | ```
1802 | backToTop();
1803 | ```
1804 |
1805 | Every time you call it, a back to top link will be output
1806 |
1807 |
1808 | #### Function parameters
1809 |
1810 | To pass variables into a function, you pass them through as arguments (or parameters)
1811 |
1812 | You reference the names of these variables between the parentheses when you define the function
1813 |
1814 | You then use the same variable name within the function declaration
1815 |
1816 | ```
1817 | function square($num) {
1818 | echo $num * $num;
1819 | }
1820 |
1821 | square(3); // === 9
1822 | square(5); // === 25
1823 | ```
1824 |
1825 | To return a value from a function use the `return` keyword:
1826 |
1827 | ```
1828 | function square($num) {
1829 | return $num * $num;
1830 | }
1831 |
1832 | $threeSquared = square(3); // === 9
1833 | $fiveSquared = square(5); // === 25
1834 | ```
1835 |
1836 | These are simple examples to show how to create and use functions
1837 |
1838 | In the real world you are likely to use more complex functions
1839 |
1840 | You could use functions to move some of the code you're writing into separate files
1841 |
1842 | For example, you could create a function that checks whether the current user is logged in. Something like this could be used at the top of every page of a website to determine whether to show content for a logged-in user or a member of the public
1843 |
1844 | ***Further information:***
1845 |
1846 | - [http://www.brandonsavage.net/how-to-write-a-function-in-php/](http://www.brandonsavage.net/how-to-write-a-function-in-php/)
1847 | - [http://webhole.net/2010/03/14/php-functions-tutorial/](http://webhole.net/2010/03/14/php-functions-tutorial/)
1848 | - [http://www.tuxradar.com/practicalphp/4/15/0](http://www.tuxradar.com/practicalphp/4/15/0)
1849 |
1850 | #### Variable scope
1851 |
1852 | When using functions, any variables that are defined outside of the function are not available within it
1853 |
1854 | Conversely any variable created within the function is not available outside it
1855 |
1856 | This is known as scope, and is very useful!
1857 |
1858 | There are some exceptions to this; as mentioned earlier, superglobal variables are accessible everywhere (globally)
1859 |
1860 | - [Variable Scope documentation](http://www.elated.com/articles/php-variable-scope-all-you-need-to-know/)
1861 |
1862 |
1863 | ### Formatting data
1864 |
1865 | In most of the examples we've seen so far, we've output data directly from the database to the page:
1866 |
1867 | ```
1868 | echo $something;
1869 | ```
1870 |
1871 | Sometimes you may want to format this information before outputting it on the page
1872 |
1873 | We have already seen a few basic examples of this:
1874 |
1875 | Concatenating strings - when outputting a name we've combined strings like so:
1876 |
1877 | ```
1878 | echo "" . $firstname . " " . $surname . "
";
1879 | ```
1880 |
1881 | Date functions - to output today's date:
1882 |
1883 | ```
1884 | echo date_format("d/m/y");
1885 | ```
1886 |
1887 | #### Changing case
1888 |
1889 | There are further options we could use to manipulate strings of text:
1890 |
1891 | To change the case of a text string we can use `strtolower()` or `strtoupper()`
1892 |
1893 | ```
1894 | $firstname = "Pete";
1895 | $surname = "Blah";
1896 |
1897 | echo "" . strtolower($firstname) . " " .strtoupper($surname) . "
";
1898 |
1899 | // pete BLAH
1900 | ```
1901 |
1902 | #### Limiting characters
1903 |
1904 | To limit text to a certain number of characters we can use `substr()`:
1905 |
1906 | ```
1907 | $text = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.";
1908 |
1909 | // first param = string
1910 | // second param = start position
1911 | // third param = number of characters to output
1912 | echo "" . substr($text, 0, 140) . "
";
1913 | ```
1914 |
1915 | (Could be useful if for example you want to output a limited summary of a review)
1916 |
1917 |
1918 | #### Replacing characters
1919 |
1920 | To replace some text with some other text you can use `str_replace()`
1921 |
1922 | ```
1923 | $original = "hello world";
1924 |
1925 | // first param = replace
1926 | // second param = with
1927 | // third param = original string
1928 | $replaced = str_replace("world", "universe", $original);
1929 |
1930 | echo $replaced; // hello universe
1931 | ```
1932 |
1933 | There are lots more examples of string functions on the PHP website:
1934 |
1935 | - [http://www.php.net/manual/en/ref.strings.php](http://www.php.net/manual/en/ref.strings.php)
1936 |
1937 |
1938 | #### Formatting numbers
1939 |
1940 | There are also lots of functions we could use to manipulate numbers:
1941 |
1942 | You could use `round()`, `floor()` and `ceil()` to round up or down a number with a decimal point, into a whole number
1943 |
1944 | ```
1945 | $lower = 3.254;
1946 | $upper = 3.836;
1947 |
1948 | echo round($lower); // === 3
1949 | echo round($upper); // === 4
1950 | echo floor($lower); // === 3
1951 | echo floor($upper); // === 3
1952 | echo ceil($lower); // === 4
1953 | echo ceil($upper); // === 4
1954 | ```
1955 | Could be useful for calculating an average rating for an item, site statistics, etc
1956 |
1957 |
1958 | #### Generating random numbers
1959 |
1960 | You can generate a random whole number with `rand()`
1961 |
1962 | `rand(1,10)` will generate a random whole number between 1 and 10 (inclusive)
1963 |
1964 | Could be used to display a random item from an array
1965 |
1966 | ```
1967 | $planets = array("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune");
1968 | $rand = rand(0, count($planets) - 1);
1969 | echo $planet[$rand];
1970 | ```
1971 |
1972 | There are lots more examples of number functions on the PHP website:
1973 |
1974 | - [http://www.php.net/manual/en/book.math.php](http://www.php.net/manual/en/book.math.php)
1975 |
1976 |
1977 | ### Sorting arrays
1978 |
1979 | The examples we saw earlier show how we can manipulate simple variables - numbers and strings
1980 |
1981 | We can also sort and filter arrays
1982 |
1983 | ```
1984 | $planets = array("Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune");
1985 | ```
1986 |
1987 | This is a standard PHP array, we already know how to access an individual item:
1988 |
1989 | ```
1990 | echo $planets[2]; // === "Earth"
1991 | ```
1992 |
1993 | To pick a random entry from an array we can use `array_rand()`
1994 |
1995 | ```
1996 | $rand = array_rand($planets);
1997 | echo $planets[$rand];
1998 | ```
1999 |
2000 | `count($array)` will give you the number of items in the array
2001 |
2002 | ```
2003 | echo count($planets); // === 8
2004 | ```
2005 |
2006 | `shuffle($array)` will shuffle (randomise) the array
2007 |
2008 | ```
2009 | shuffle($planets);
2010 | print_r($planets);
2011 | ```
2012 |
2013 | `array_reverse($array)` will...reverse an array
2014 |
2015 | ```
2016 | $reversedPlanets = array_reverse($planets);
2017 | print_r($reversedPlanets);
2018 | ```
2019 |
2020 | `array_unique()` will remove any duplicates
2021 |
2022 | We can add to or remove from the array:
2023 |
2024 | - `array_pop()` to retrieve and remove the last value
2025 | - `array_shift()` to put a value at the start of an array
2026 | - `array_push()` to put a value at the end of an array
2027 | - `array_unshift()` to retrieve and remove the first value from an array
2028 |
2029 | There are lots more examples of array functions on the PHP website:
2030 |
2031 | - [http://www.php.net/manual/en/ref.array.php](http://www.php.net/manual/en/ref.array.php)
2032 |
2033 |
2034 | ### Using PHP or MySQL to sort data
2035 |
2036 | When choosing between sorting data with PHP or MySQL, it is more efficient to do as much as possible in the original SQL query
2037 |
2038 | For example, you could `SELECT * FROM questions`, then loop through all the results in PHP to decide whether to output the current question
2039 |
2040 | But it is more efficient to filter in the SQL query...
2041 |
2042 | ...unless you are going to re-use the data elsewhere
2043 |
2044 |
2045 | ### File uploading
2046 |
2047 | #### Client-side code
2048 |
2049 | We can use HTML forms to upload files to the server
2050 |
2051 | We've already seen the standard structure of an HTML form
2052 |
2053 | In order to enable a form to upload data, add an extra attribute:
2054 |
2055 | ```
2056 |
2803 | ...
2804 |
2805 | ```
2806 |
2807 | We could just include a file containing the HTML at the relevant point:
2808 |
2809 | ```
2810 |
2811 | ...
2812 |
2817 | ...
2818 |
2819 | ```
2820 |
2821 | This is one way to store information, as ready-made HTML
2822 |
2823 | But there are some issues:
2824 |
2825 | - It's not a true separation of data from its display
2826 | - You can't re-use this information in other ways
2827 | - (Each country name is surrounded by an element so couldn't be used in any other way)
2828 | - There are more efficient ways of doing this - we could use PHP to transform it dynamically
2829 |
2830 |
2831 | Looking at the structure of the original countries HTML, there is a new line (or row) for each item of data
2832 |
2833 | On each line there is the country name with an ` ` element surrounding it
2834 |
2835 | If we had just a list of country names, we could recreate this programatically using PHP
2836 |
2837 | Now rather than just inserting the file into the page, we'll need to read and process it with PHP
2838 |
2839 | To read the file we use the built-in PHP functions `file()` and `file_get_contents()`
2840 |
2841 | ```
2842 |
2843 | ...
2844 | ";
2850 | }
2851 | ?>
2852 |
2853 | 
`
126 | - `Links`
127 |
128 |
129 | ### HTML rules
130 |
131 | There are a few simple rules:
132 |
133 |
134 | #### Opening & closing tags
135 |
136 | Tags wrap around the content they describe:
137 |
138 | ```
139 | 
165 | ```
166 |
167 |
168 | #### Nesting tags
169 |
170 | Tags should be properly nested
171 |
172 | ***WRONG***
173 |
174 | ```
175 |