These elements have the inherent property of creating a new line of content when displayed, forming discrete blocks of content when rendered by the browser. The most general block element is the <div> tag, which is primarily used to identify each section using the unique id attribute. The stuff contained within a given division is isolated from the rest of the page and styled according to the attributes of the enclosing <div> tag.

More familiar forms of block elements include the heading tags (<h1>, <h2>, etc.) and <p>. Each has specific properties, such as text size and weight (boldness), for which you can specify values other than the defaults. The break tag, <br />, is sometimes considered a block element too, because it forces a new line to be rendered in the page display.

Example: <div id="me"><p class="others"><br /></p></div>

For the content contained within block elements, different words may require different presentation. XHTML allows for some special inline elements to handle this without explicitly defining a style. The two most commonly used elements are <strong> and <em>. By default, the former makes text boldface, and the latter displays text in italics.

Example: This is <strong>boldface</strong>.

List tags are a special category of XHTML element, sort of a cross between block and inline elements. Wrapping content in list tags will force a line break (as with a block element), but these tags are also used to indent or mark specific lines of text. There are tags for three kinds of lists: unordered lists (<ul>), ordered lists (<ol>), and definition lists (<dl>). Which tags you use dictates how the list items are presented.

List tags are nested. Each item in an ordered or unordered list must be wrapped in <li></li> tags, and the collection of all the list items must be wrapped in <ul></ul> or <ol></ol> tags. (Definition lists are a special case that we won’t go into here, as the sample applications in this book don’t use definition tags.) Unordered lists place bullet characters before each item. Ordered lists use a sequence of numbers, letters, or Roman numerals.

Example: <ul><li>tom</li><li>jerry</li></ul>

Arguably the most important tag in the bag of XHTML tricks is the hyperlink tag. Without it, web pages would have to be bookmarked and loaded separately. Linking is what makes Google searches work.

You can make any text, image, or object an active hyperlink by wrapping it in anchor tags (<a></a>). Anchors can be used to point to somewhere new, using the href attribute and a referenced web document, and to name a particular bit of content. Naming comes in handy to connect XHTML to JavaScript or links from other pages.

Another attribute, title, further empowers links. The title attribute can store useful descriptive or instructive information that becomes visible in many browsers when you move your mouse over the hyperlink.

Example: <a href="#" title="hi">click<a>

Adding images to your web page may slow down the page loading a bit, but it also makes the experience more enjoyable for visually perceptive visitors. The bandwidth and access limitations of a decade ago, which discouraged the use of images on web pages, are disappearing, as most U.S. homes now have broadband access.^[60] Graphics—whether they’re big pictures dominating the page or a few custom icons used for bullet points in a list—enhance communication and enjoyment.

The <img /> tag—a singleton that does not have a matching closing tag—has an attribute, src, that points to a file accessible via the Web. The file can be in any one of a number of formats, but for graphics the most acceptable formats are .gif, .jpeg, and .png.

Although most browsers don’t require it, image tags also need an alt attribute to be compliant with W3C standards. Alternative text has two important purposes. First, before the browser successfully downloads the image, it uses the text in the alt attribute as a placeholder in the page display. More importantly, alternative text is used by web browsers for visually impaired people to describe the images those visitors cannot see. Alt text can be blank for images meant for decoration only, but otherwise, the value should be a short and meaningful description of the image.

The other attributes that are helpful to include are width and height. These default to the actual pixel size of the image file if not included, but specifying them in the code allows the browser to carve out the appropriate bit of screen real estate while the image loads. The rest of the page is then unaffected by when the graphic decides to show up. These attributes also allow for resizing a graphic on the fly, as their values will override the dimensions of the image for purposes of rendering the web page.

Example: <img src="hi.jpg" alt="Hi" width="8" height="8" />

The hash references a specific ID attribute associated with a tag element in the XHTML structure. Each ID selector can be used only once per page.

Example: #whoopi { color:purple; }

The full stop, or period, references a specific class attribute associated with one or more tag elements in the XHTML structure. Classes can be used as many times as you want and are great for formatting repeating content, such as dynamic lists.

Example: .kermit { color:green; }

They can also be used in conjunction with a specific kind of tag to set a style for that combination of element and class. Because this is more specific, it will take precedence over the class alone.

Example: h4.kermit { color:black; }

The asterisk is a wildcard character that can be used to set the default style for any unassigned tag elements in the page. This is often used as the first style declaration, to set the font size and family for the entire page.

Example: * { font-family: sans-serif; font-size: .9em; }

You can also use the wildcard to apply styles to everything contained in a specified selector. However, this can lead to frustration if you accidentally overwrite a specific style declared elsewhere in the sheet.

Example: #sidebar * { color: blue; }

Spaces are used to build a complex string of selectors into a nested style. A nested style is inherently weighted with greater priority than a single-element selector because it is more specific. You can, for example, define all anchor tags to be underlined (that’s the default interpretation by the browser, actually) but turn off the underlining for links in a specific division.

Example: #subtle a { text-decoration:none; }

Commas are used to group several selectors together and assign them the same style properties at once. This is useful when a number of selectors share the same subset of styles. Any differences can be declared separately for each selector.

Example: #one, #two, #three { color:red; }

The “box model” best describes margins, padding, and borders. If you picture the content of an element as the innermost box and the element border as the outermost box, the padding is the space between the content and the inside edge of the border. The margin is the space between the border and the nearest other elements on the page. This extra space is like a force field that protects other content from crowding the parts of the element.

Values for the padding and margin properties can take many forms, including percentages and specific lengths. Lengths are typically measured in terms of pixels (px), which are absolute, or em-length (em), which is a relative measure based on the width of the letter “m” in the chosen font. Margins can also have a special value, auto, which will attempt to balance the spacing between elements. This is often used to center a block of content on a web page.

Example: #content { margin:20px; padding: 1.5em; }

Floating an element moves it to the right or the left of the other elements within the parent element, as content flows around it. Floats are used to create sidebars or to describe the relationship between an image and its surrounding text.

Example: #sidebar { float:right; }

This property sets the horizontal dimension of an element. The width is measured without consideration of the margin, border, or padding values (or as if all three values were set to zero). Remember that there is both a left and a right side to any element, so a division with a width of 100, padding of 10, border of 1, and margin of 20 would take up 162 pixels across the page (100 + 10 + 10 + 1 + 1 + 20 + 20 = 162).

Example: #column { width:350px; }

This property sets the alignment of text within a block element. The usual suspects are possible values (left, right, center, justify). text-align cannot be used to affect the placement of a division; instead, use the float property to move divisions to one side of the page or the other.

Example: h2 { text-align:center; }

We sometimes take for granted, based on experience, that certain tags will be rendered in specific ways. Header tags result in larger, boldfaced text, with some vertical spacing above and below. List items are indented and have space between each new item. All of that presentation, though, is part of an accepted interpretation of style properties that the browser adds to the page upon seeing those tags.

With the display property, you can assign some of those properties to any tag element. Division tags can become inline objects and anchor tags can become block elements. Either can be displayed as list items. This kind of reappropriation of inherent properties is not frequently done, but display does have one very useful value: none. This effectively hides the element and all of its contents from display. With the incorporation of JavaScript, this value can be changed on the fly, making pop-up content and contextual menus possible.

display differs from another property, visibility, in that with display the hidden elements are not factored into the positioning of the visible elements on the page.

Example: #help { display:none; }

In word processors, changing the shape of the letters to match a typographical set of characters is as easy as selecting from a menu. Your computer scans your operating system for the presence of fonts and lists all the ones it finds as options. A web browser has access to this same list of fonts, but the basic list differs from one computer platform to the next and can be expanded by installing extra fonts. To make a web browser try to use a specific font, the CSS must be coded to pass that request on to the client.

The font-family property allows the web developer to send a comma-separated list of font names to the browser, which will use the first one that it recognizes as available in its system. For this reason, any exotic fonts should be either avoided or listed with other, more common fonts that are likely to be available. The list of values should end with a general family type—such as serif, sans-serif, script, or monospace—to direct the browser, as a last resort, to pick the system- or user-defined preferred font for that general category.

Example: * { font-family:Helvetica,Arial,sans-serif; }

The size of the text is dictated by the font-size property, which can accept values that range from percentages to length units to keywords (smaller, larger, xx-large, etc.) that are interpreted by the browser. The values are most commonly expressed in terms of px (pixels), pt (points, the default), or em. Em-length is often preferred, since it is calculated from the current size of the text. A font-size value of .9em would cause the text to be rendered at 90% of the size it would be without the new style definition, and 2em would cause the text to be rendered twice as large.

Example: p { font-size:.9em; }

Colors can be assigned to any object to describe both its text (or border) and the background fill upon which that text rests. There are a number of predefined color names: aqua, black, blue, fuchsia, gray, green, lime, maroon, navy, olive, orange, purple, red, silver, teal, white, and yellow. The color can also be expressed as a hexadecimal value (#00ffcc) or its decimal equivalent (0,255,204) to indicate how much red, green, and blue to mix to form the desired color.

The background-color property also accepts a value of transparent, which means whatever colors, images, or text are underneath the layered object will be visible. This is the default, which is why setting the background color of the body will result in all elements having a background of that color.

Example: #sidebar { color:green; background-color:black; }

This property deals with some of the less common style changes for text, such as strikethroughs, overlines, and underlines. It’s useful if you want to remove an underline, such as the one added to a hyperlink by default. text-decoration can also cause things to blink, which is probably a sign that we aren’t learning from past mistakes.

Example: a { text-decoration:none; }

Rather than building a loop to check every value in your array, you can use the array_search() function to look for matches with a search string or multiple values stored in an array. The function returns the key for the first match it finds.

This function encodes data as base64, returning a new string that is a bit (33%) larger than the original. It is used to make data safe for transfer to destinations where some of the characters may cause problems. The base64_decode() function will convert text that has previously been encoded with base64_encode() back into its original string.

This function takes a string containing the path to a file and returns the base name of the file. For instance, if the path is /path/to/file.php, basename() will return file.php.

This function takes an ASCII string and returns the hexadecimal equivalent.

The math function ceil() turns a value into the next highest integer, or the ceiling for the number.

The date() function turns a numeric version of the time into a formatted string. The template for that resulting string is dictated by the letter codes used as placeholders for the various parts of the date and time. For example, “l, F jS, Y G:i:s a” would produce something like, “Thursday, December 25^th, 2008 6:21:34 am.”

The dechex() function converts a hexadecimal string into a number. The input value can be no more than eight characters long. This is the opposite of hexdec(), which performs the conversion the other way.

The explode() function converts a long delimited string into an array of strings. You specify the character(s) to use as a delimiter, and it splits the provided string into parts at every instance of that delimiter. The parts then become separate indexed values of a new array. The companion to this function is implode().

This function works in the same way as date(), turning a numeric timestamp into a formatted string to represent the date and time. The difference is that the time is expressed in Greenwich Mean Time (GMT) rather than in the local server time zone.

Hashing involves use of a specific algorithm, such as sha256, to encrypt a string. This is a one-way process used to store sensitive information, such as passwords, for comparison with user-entered information as a way of verifying access. There is no mathematical way to reverse-engineer this, although lookup lists can be generated to re-map back to the original string. It isn’t easy, especially if you salt the password by adding a random string to the password being stored.

Example: $secured = $salt.hash('sha256',$salt.$password);

This function recognizes that some characters—namely, the ampersand (&), double quote ("), single quote ('), less-than symbol (<), and greater-than symbol (>)—have special meaning in HTML and may cause text containing them to be rendered inappropriately. The htmlentities() function is often used to prevent text submitted by the user from rendering as HTML by substituting translations for these characters. It is similar to htmlspecialchars() but substitutes more comprehensively.

You can reverse the translation by using html_entity_decode().

This is an important function that bridges the gap between strings and arrays. You can use implode() to turn an array into a single string by specifying a delimiter character(s) that will connect each value in the array. This is the reverse of the process performed by the explode() function.

Like the array_search() function, this function is a way to search through the values stored in an array for keyword matches. The in_array() function simply confirms with a Boolean whether or not a match is found.

This function tests to see whether a given variable value is an integer, returning a Boolean as a result.

The mt_rand() function is one of many random number generators that aren’t truly random, but that generate pseudorandom values that work well enough to make programs seem unpredictable. This one is a bit faster than the rand() function, which is why it is preferred.

This versatile function accepts up to four parameters to return a string that adds formatting to a numeric value.

The pack() function uses formatting codes inherited from Perl to turn a list of arguments into a binary string. The binary string can be turned back into an array of arguments with unpack().

This is a search-and-replace function that uses pattern matching to locate the places to insert replacement text into a string.

Example: $x = preg_replace('/&(?!w+;)/', '&', $x);

When arrays are navigated, the internal pointer is incremented to reference items with higher and higher indices. The reset() function returns that pointer to the first element in the array.

This function counts the number of items in an array. count() is an alias for sizeof().

For most PHP configurations, quotation marks within the user-submitted text are automatically escaped to allow for operations such as saving to a database, where they could mess things up. There are times, though, when that is overkill. The stripslashes() function will remove those escaped characters.

Back in the day when all formatting was done with monospaced characters, lining up numbers and text in columns required some padding spaces or other characters. The str_pad() function makes that easy by asking for a minimum length for the resulting string and the text you want to use to make a shorter string that target size. By default, the padded characters will be added to the right of the initial string, but you can specify instructions to pad to the left side (for numbers, typically) or on both sides (to center the string).

The sample applications make use of str_pad() in password encryption to make sure that the salt strings are all the same size.

This function works like preg_replace() except it is more straightforward, ditching regular expression matching with a simple string to match. It returns an array with all of the occurrences where the value was replaced.

This encoding function simply shifts every letter it finds in a string by 13 places in the alphabet. Any numbers or other nonalphabetic characters are ignored. Decoding is accomplished simply by running the result back through the same str_rot13() function.

Just as sizeof() returns the number of items in an array, strlen() returns the number of characters in a string.

Whereas strcmp() treats numbers as text, the strnatcmp() function is able to order strings based on “natural ordering,” or the way a human would read and interpret a string. That is, instead of ordering a list “1,10,2,20...”, this function would correctly interpret the order as “1,2,10,20...”. It returns an integer value between −1 and 1 to indicate whether or not the first string should be ordered before the second. It is more often used with usort() to help order entire arrays of data.

Like array_search() does for arrays, the strpos() function returns the position of the first match of the given text found within the specified string. Since it returns the Boolean false if the text is not found in the string, this function is also useful as a conditional to confirm whether a match exists.

This function simply reverses the character order of a given string. The result can be decoded by running it through the same strrev() function again.

When case is not important (as is typical of usernames), it is good practice to turn strings into lowercase for storage and comparison. The strtolower() function changes any capital letters into lowercase.

There are many different ways of conveying a date and time. Many of these are variations of the numbers and text we commonly use to report time in a readable format, such as “January 30 2000 11:13:00 GMT.” For PHP to be able to do any calculation on that moment in history, the text has to be converted to its numeric counterpart. This is performed with the function strtotime(). If no string is provided, the current Unix timestamp will be returned.

To extract a part of a larger string, use the substr() function to specify the starting point within that string and optionally the length of the new string. If the starting position is negative, the extraction will be done from the end of the original string, rather than the beginning.

Sometimes data is entered or recalled with leading or trailing whitespace. This can include ordinary spaces as well as tabs, returns, and newlines. The trim() function will examine both ends of a string and clip off any whitespace it finds there.

The urlencode() function adjusts a string of text to turn any special characters to a URL (such as an ampersand) into characters safe for transfer in a URL query string. Some are converted to a different character (for example, a space is converted to a plus sign, +), whereas most become hexadecimal codes tagged with a % symbol, as in %7E.

This adjustment should be made before any text is passed to a form as a URL query string. The urldecode() function will return a string that restores all %## translations back to their original characters.

Arrays can be sorted in very complex ways. The usort() function allows you to reference another function for comparing two values and use it to order the contents of a given array. The function is typically one of custom design and must provide the same kind of response as an existing comparison function, such as strnatcmp(). That is, the comparison between two values should return an integer between −1 and 1 to indicate which of the two values should precede the other.

The utf8_encode() function encodes a string to UTF-8, a Unicode standard that deals with wide character values.

Whereas a $_SERVER variable will reflect the file that was requested via the Web, __FILE__ always refers to the full path and filename of the script in which it is invoked. That means an included file will have a different __FILE__ value than the main script that called it.

The document root is the directory path on the server from the top of the configured file structure to the directory root under which the current script is running.

The host usually contains the domain information part of the URI request. SERVER_NAME likely holds the same value.

If there is a query string—the part of a URI that comes after the filename, following a question mark (?)—that entire part of the request string will be stored in this variable. This information is likely also pre-parsed into name and value pairs in the $_GET associative array.

Several kinds of HTTP request methods are possible, but most web pages deal with just two: GET and POST. This server variable stores the name of the method used to access the script and can be useful in determining where to find any user-provided input parameters.

This variable contains the URI that was used to trigger the web page script, once the request arrived on the server. This does not include the protocol and domain, only the server path after the web root (as in /index.php). The REQUEST_URI will also include the query string, if one exists.

The SCRIPT_NAME is the current script’s path. This is often the same value contained in REQUEST_URI, but without a query string, if one exists. Unlike __FILE__, this variable will reflect the path to the requested file, not the one invoking the variable.

To read from or write to a file, PHP must be able to reference it in some way in the code. The fopen() function creates a file handle that binds to a stream connecting PHP to the contents of the specified file. For this to be successful, PHP must have access to that file, meaning that it not only must be reachable but also must be configured with the appropriate permissions.

There are a few different ways PHP can open the file. fopen() asks you to declare the mode (a code that dictates whether you can read from and/or write to the file), where the pointer should be located when it opens the file, and what to do if the file already exists. For logging—where you only need to add a line of text to whatever is already in the file, and worry about reading the contents at a later time—the mode "a", for append, is sufficient.

Once a file is open in a mode that permits writing, the fwrite() function can be used to enter a string of text into that file. The file is referenced through a file handle, not by the path and name of the file itself. Prior use of fopen() is required to create that association.

Assuming the file handle pointing to an existing file is valid, fclose() terminates the association between PHP and the file stream.

This function deletes the file specified in the parameter, provided it exists and permissions on the server allow it.

If you want to create a virtual browser and retrieve content available on the Web, the file_get_contents() function can help. Enter an encoded URI, and a string will be returned containing the contents of that file, as rendered by the web server. If the retrieval fails, the function will return a Boolean false.

This function can also point to a local file, acting as three functions in one by opening, reading, and closing the file connection. file_get_contents() is used in the sample applications in this book to create a TinyURL that can be included in a direct message to a Twitter member.

This function initiates the connection between PHP and the MySQL database server by specifying the server location with access information. The function mysql_connect() returns a link to the database upon success.

A database server can host multiple databases. For your queries to retrieve the data you want, you have to specify one of the available databases on the server. The database name passed to this function will become the current active database associated with the open database link. All communication will be with that database.

The link to the database connection can be specified, but if it isn’t, this function will use the link last opened by mysql_connect(). If no connection has been made previously, it will try to make a new connection without any parameters.

The mysql_query() function passes a single SQL statement to the current active database through a valid link to the database server. For queries that are meant to fetch data, the function returns a result set. For other queries that are intended to perform some action (like an INSERT or DELETE statement), a Boolean is returned to indicate success or failure.

When you are using the command line or files to run SQL statements, a semicolon is required to let MySQL know when to stop reading the query. This function deals with that internally, and therefore SQL statements passed as parameters should not include semicolons.

For queries where no records are expected, such as DELETE statements, this function returns the number of rows that were affected. If the query fails, a negative value is returned.

For queries where records are expected, this function returns the number of records in the result set.

Generally, you’ll connect to a database to get data from it. The result set stored in the numerical array returned by mysql_query() can be parsed using mysql_fetch_array(), looping each row of data in a foreach block. This function automatically moves the array pointer to the next index when called, returning a Boolean false when there is no more data.

As with URIs, there are characters that have special meaning for MySQL and thus should not be included in the queries you submit. Failing to screen for these characters may lead to trouble, ranging from merely causing the query to return an error all the way to allowing malicious activities with the database. The mysql_real_escape_string() function examines MySQL’s own library of special characters and replaces them with safer versions. Because of the potential for disaster and the ease of its use, there is no reason not to escape all text strings before sending them to the database.

This function clears the results of the last query, which has two advantages. First, it lets the server know that the memory used to store the previous data is now available for other things. Second, it eliminates the chance that you may accidentally reuse the same result set.

Assuming the handle representing the database link is valid, this function disconnects PHP from the database server. The link to the database will automatically end when the script finishes running, but it is good practice to close it explicitly.

When you want to start building XML from scratch, SimpleXMLElement can help. It turns a well-formed XML string or a path to a file containing XML data into an object that can be iterated, edited, and expanded with a variety of methods. The object is a collection of tag names associated with the content the tags contain and the attributes they are assigned. Nested tags show up as objects that themselves can be parsed into tag names, attributes, and values.

Example: $xml = new SimpleXMLElement($base_xml);

For simply parsing XML data that already exists, this function takes the data in the form of a string and returns a navigable object.

Example: $xml = simplexml_load_string($data);

The getName() method returns the name of the root tag for a particular XML object. When the XML object is first created, this will be the main root of the document, but this method can be used for nested objects as well.

Example: $root = $xml->getName();

The children() method creates an iterative array of objects representing the nodes directly below the XML object calling it. Each child object can then be explored for a name, value, attributes, or any other XML objects it contains.

Example: foreach($xml->children() as $x) {$ids[] = $x->id;}

This method is what allows you to create your own XML documents. It accepts a text value to describe the name of the new nested tag and any value you want it to contain. It returns the new XML object, which can then be edited and expanded as if it had been part of the original XML.

Example: $xml->channel->addChild('newchild','my text'),

All of the manipulation of addChild() only changes the XML object that PHP has stored in memory. To make the changes real, you need to turn the object back into a string of well-formed XML text. This can be printed or stored in a string for later use in the application. asXML() will also accept a filename parameter and write the file directly to a document.

Example: echo $xml->asXML();

As with the SimpleXMLElement object, a new DOMDocument object can be created using this method to hold the XML data you want to explore. This gives PHP a framework for loading and parsing the structured data.

Example: $doc = new DOMDocument();

To fill the new DOM object with XML data, you have to let PHP know where to look for that data. For RSS feeds, the simplest technique is just to point to the URI for the data you are trying to parse. This path can also point to local files, returning a Boolean true or false to indicate success. The object must already exist before it can be filled.

Example: $doc->load($url);

The DOM can retrieve a specific node from the full document, returning it as an object containing all of the matching objects. The getElementsByTagName() function creates a new instance of the node class, giving it access to more tools to explore the node in detail.

Example: $items = $doc->getElementsByTagName('item'),

At the node level, the value a particular node contains within its start and end tags can be retrieved with nodeValue(). The value can be a date, text, number, or other data type, depending on the kind of node being explored.

Example: $title = $item->item(0)->nodeValue;

Another tool at the node level is getAttribute(), which returns the value associated with a tag attribute, such as the link stored in the href of an anchor tag. If an attribute is not found, an empty string is returned. For singleton tags, the attributes are where the node data is located.

Example: $link = $node->item(0)->getAttribute('href'),

To use cURL to access a remote file, you must first create a handle that can be used to reference the connection later in the program. curl_init() can be initialized as an empty shell and filled later, either by setting the CURLOPT_URL option or by passing a URL as a parameter. The new handle is returned upon success.

Example: $cURL = curl_init();

The curl_setopt() function allows you to configure an initialized cURL handle by setting some of its many options. The options are named with the CURLOPT_ prefix and include the following, which are used in the sample applications for this book:

The curl_setopt() function returns a Boolean to indicate success.

Example: curl_setopt($cURL, CURLOPT_URL, $curl_url);

When you have to set a number of options at once, it may be easier to first create an associative array filled with the option names and values to send to cURL all at once. curl_setopt_array() sets multiple options for a cURL session. Specify the active cURL handle and the array of options, and the function will return a Boolean to indicate success. If any single option fails, the remainder of the array will be ignored and the function will return false.

Example: curl_setopt_array($cURL, $cURL_options)

The meat of this suite of functions is curl_exec(), which actually executes the session as it is currently configured. If the CURLOPT_RETURNTRANSFER option has not been set to true, this function will output whatever it finds at the other end of its request and return a Boolean to indicate success. Otherwise, curl_exec() returns the contents to save in a string.

Example: $twitter_data = curl_exec($cURL);

Each request has a meta-information channel that describes the session that was just executed. curl_getinfo() gets that information and either returns it as an associative array containing all the available data or, if you include a specific variable name, returns just that variable’s value. The meta-information includes url, content_type, http_code, filetime, total_time, size_download, speed_download, and download_content_length.

Example: $status = curl_getinfo($cURL, CURLINFO_HTTP_CODE);

When you’re finished, use curl_close() to end the session and free up all of the application resources that were devoted to the HTTP request.

Example: curl_close($cURL);

Racks of machines are set up, and your account shares physical and virtual space with other accounts. If their sites go down, so do yours. If you stress the processor with a bunch of big queries, other accounts suffer the consequences, too.

Your slice of the big shared hosting pie includes CPU, RAM, and disk space that are not affected by and will not affect what happens on other VPS accounts. You can have root access to your virtual machine.

You own the server, but you don’t have to maintain it. This arrangement is like VPS, except that “virtual” is replaced with “physical” (your server is a real machine that no one else uses).