With some String functions, you can create your own function to parse a query string attached to the request url and store it in an associative array – just like PHP would for you.

What Are Query Strings For

If you’re developing anything more than a basic informative page, you’ll need to pass information from one page to the next. You might want to pass a search query, some form values, the answer to a quiz question, or any number of other things. Passing this information is the first step in converting your page from a static bit of information into a dynamic application.

One way to pass information between pages is to use a query string. That’s the long line of text after the ‘?’ in a URL. Kind of like this.

http://www.google.com/search?hl=en&q=widgets&btnG=Google+Search

That’s a standard query string attached to a Google search. It sends a few values to the new page – hl (en), q (widgets), and btn (Google Search). These values are then used to determine what is displayed on the new page.

In PHP, these values are automatically stored in an associative array – the $_GET array. To make these values easily available to our Javascript code, we can write a function to do the same thing.

The Structure of a Query String

In order to break a query string down, we need to understand the rules for building one.

A query string always starts with ‘?’. This separates the query string from the actual URL.

This is followed by key-value pairs, like “key=value”. If there is more than one key-value pair, they are separated by an ampersand – “key1=value1&key2=value2″.

Finally, these values are url_encoded. Special characters – like spaces, ampersands, and equal signs – are converted to code so that they don’t interfere with the URL or the query string.

Step One: Get the Request String and Separate the Query

The first thing we need to do is get the entire request string and separate out just the query string.

//  Fetch the entire request string
var href = new String(window.location.href);
var hrefParts = href.split('?');
 
//  [0] is the URL, [1] is the query string
var query = new String(hrefParts[1]);

The request string is accessible through the window.location object. We use the split method of the string class to explode it at the ‘?’. This leaves us with two parts, and we save the entire query string in the variable query.

Step Two: Get the Key Value Pairs

At this point, our query string in the variable query might look something like this:

hl=en&q=widgets&btnG=Google+Search

To get the key-value pairs, we can use another split() call. This time, we split the string at each ampersand (&). The resulting array will contain the strings “hl=en”, “q=widgets”, and “btnG=Google+Search”.

var valuePairs = query.split('&');

Step Three: Loop Through and Create an Array

Now we can loop through the array valuePairs, split each pair, and create a new array where each value is indexed by its key. This gives us a nicely indexed array just like PHP would.

var getArray = new Array();
 
for each (var pair in valuePairs) {
  // [0] = key, [1] = value
  var tempPair = pair.split('=');
 
  // Unescape converts the text back from URL encoding
  getArray[tempPair[0]] = unescape(tempPair[1]);
}

At this point, getArray[] should hold all of the values in our query string.

Why Bother?

Good question. If PHP (and other server side scripts) automatically parse query strings, why should we bother using Javascript for it?

One reason may be to use query strings to pass information on pages that don’t have any server side scripting enabled. I was looking into a web design competition for high school students, and it doesn’t allow any server-side scripts – only HTML, CSS, and Javascript.

With this method, we could use query strings to bring a little dynamism to the party.

This is also helpful for reading query strings in general – not just the one in the request string. For example, if you use Ajax to get a value from a php script, how is the output formatted?

It may be plain text if it’s just one variable, or it may be in an XML format. If the output is just a handful of key-value pairs, it might be easier and more efficient to create a query string and parse it with this function.

Or… maybe it’s just fun to say “I can do this.” That’s a good enough reason for me.

And as usual, here’s the full function, in case you had some trouble.

function parseQueryString(fullHref) {
  var hrefParts = fullHref.split('?');
 
  //  [0] is the URL, [1] is the query string
  var query = new String(hrefParts[1]);
 
  var valuePairs = query.split('&');
  var getArray = new Array();
 
  for each (var pair in valuePairs) {
    // [0] = key, [1] = value
    var tempPair = pair.split('=');
 
    // Unescape converts the text back from URL encoding
    getArray[tempPair[0]] = unescape(tempPair[1]);
  }
  return getArray;
}
 
//  To use it, pass the request string or another href
//  to the function.  It returns the array.
var href = new String(window.location.href);
var getArray = parseQueryString(href);

The concept seemed simple enough, but I ran into a problem – I didn’t know how to do string replacement in Javascript. The first thing I thought was, “What is the Javascript equivalent to str_replace?”

The JS str_replace – String.replace()

As it turns out, the closest thing in Javascript to str_replace is the replace method of the String class. It’s actually more akin to preg_replace – since it uses regular expressions – but it’s the closest thing I could find for a built-in string replacement function.

It’s implementation is pretty simple. Create a new string object. Then call the replace method with two parameters – a regular expression to match and a string to replace it with.

var hello = new String('Hello World!');
var goodbye = hello.replace(/hello/i, 'Goodbye');

In this example, we do a simple search for the word ‘hello’ (the ‘i’ signifies that the search is case insensitive). When we find ‘hello,’ we replace it with goodbye.

Using Variable Values Inside Regex

That’s simple enough. However, what if you don’t want to hard-code the regular expression?

I was left wondering how I could use a variables value within the regular expression for the search. If I placed the variable inside the / / boundaries of the regex, it would simply search for the name of the variable.

I eventually stumbled across the RegExp class – which incidentally makes it easier to build a regex expression. You create an instance of the RegExp class by passing it two parameters – the string to match and any modifiers (‘i’ or ‘g’) that should be used for the search.

var hello = new String('Hello World!');
var matchWord = new String('hello');
var match = new RegExp(matchWord, 'i');
 
var goodbye = hello.replace(match, 'Goodbye');

This has the same effect as the last example – except now the string to match comes from the variable matchWord. With this, you could use some type of user input to determine what to match and replace.

Recap – Replacing Strings in Javascript

To recap…

• There is no direct equivalent to str_replace in Javascript.
• Use String.replace – which is very similar to preg_replace.
• Two parameters – a regex to match and a string to replace it with.
• Build an instance of the RegExp class to use variable values in your regex.
]]> http://www.earn-web-cash.com/2008/02/22/javascript-str-replace/feed/ 2 http://www.earn-web-cash.com/2008/02/21/create-rss-feed-simplexml/ http://www.earn-web-cash.com/2008/02/21/create-rss-feed-simplexml/#comments Fri, 22 Feb 2008 01:48:07 +0000 Walkere http://www.earn-web-cash.com/2008/02/21/create-rss-feed-simplexml/ RSS feeds are a must-have for modern websites. It’s easy enough to make an RSS feed of recent articles in PHP. But did you know an RSS feed can simply be information – not links to articles?

This article will look at how to build a basic feed of data – for our purposes, we’ll consider random quotes. It will also illustrate how to use SimpleXML to build the feed for us.


The RSS 2.0 Standard

RSS feeds, like XML in general, have specific standards. In order to be use-able across platforms, it is imperative that standard syntax and naming patterns are used. If you’re unfamiliar with the RSS 2.0 standard, you should look through a copy here.

Before we get to building the feed, let’s identify what tags we’re going to use.

The entire feed is wrapped in an <rss> tag. Within that element is a <channel> element.

The <channel> element has a number of optional child elements. The basic ones we’ll want to include are – <title>, <description>, <link>, and <pubDate>.

The actual data (our random quotes) is wrapped in <item> elements. These also have a bunch of optional parameters. We’ll be using the basics – <title;>, <description>, and <pubDate>. Notice that there’s no link – because we’re feeding simple data, not articles!

Creating the SimpleXML Object

In order to create the SimpleXML object, you need to feed it some kind of XML string. Normally this would be a completed file or string – like an existing feed.

Since we’re building the feed with SimpleXML, we don’t have a lot to start with. We can give it a very basic string to create the object – an opening and closing rss element.

$xml = new SimpleXMLElement('<rss version="2.0"></rss>');

Adding Child Elements

The addChild() method of SimpleXML allows us to add child elements to existing elements. In addition to adding a child element, the method returns a reference to the new child – allowing us to manipulate it in turn.

The first child we’ll need to create is the channel element.

$channel = $xml->addChild('channel');

That creates the channel element and stores a reference to it in $channel. We can then use the $channel variable to add more children – the information defining the channel element itself.

$channel->addChild('title', 'Test Feed');
$channel->addChild('link', 'http://www.earn-web-cash.com');
$channel->addChild('description', 'This is a feed testing how to build an RSS feed in SimpleXML');
$channel->addChild('pubDate', date("D, d M Y H:i:s T"));

You may want to include other optional parameters that are included in the specification. Just add another $channel->addChild() call with the parameter’s name and its value.

Creating the Random Quote Items

At this point, we just need to add our item elements and we’re done. To do that, we’ll loop through an array of data, create an item element, and add the appropriate children to it.

Let’s assume that I retrieved information from a database table with three columns – title, description, and pubDate.

while ($row = mysql_fetch_array($result)) {
  $newItem = $channel->addChild('item');
  $newItem->addChild('title', $row['title']);
  $newItem->addChild('description', $row['description']);
  $newItem->addChild('pubDate', date("D, d M Y H:i:s T", $row['pubDate']));
}

Again, you can add extra data to your feed by adding extra child elements.

Outputting the Feed

Now that the entire feed is stored in the $xml variable, we just need to output it.

In doing this, we’ll do two things. We need to define the content-type as xhtml/xml. Then we use the asXML() method to print the information in an xml string.

header('Content-Type: application/xhtml+xml');
echo $xml->asXML();

You could alternatively save this to an xml file. There are two ways to do this – either file_put_contents the output from asXML() or pass a filename as the parameter for asXML().

file_put_contents($filename, $xml->asXML());
//  or ...
$xml->asXML($filename);

Start Feeding

With this basic script, you can serve up any kind of information as an RSS feed. This makes it easy for people to read it in their RSS readers or even access the information on the cell phones.

There are plenty of types of data you could use this for – quotes, jokes, question of the day, trivia, tip of the day, etc. By publishing tiny bits of data on a daily basis, you keep your users coming back for more – but you don’t need to publish full size articles every day.

In case you ran into trouble putting the script together, here’s the entire source code with an array of data built into it.

$items = array();
$items[] = array('title' => 'Mark Twain on Profanity', 'description' => 'Under certain circumstances, profanity provides a relief denied even to prayer.');
$items[] = array('title' => 'Woody Allen on People', 'description' => 'It seemed the world was divided into good and bad people. The good ones slept better... while the bad ones seemed to enjoy the waking hours much more.');
$items[] = array('title' => 'Will Rogers on Vets', 'description' => 'The best doctor in the world is the veterinarian. He can\'t ask his patients what is the matter - he\'s got to just know.');
 
//  Create the root element - RSS
$xml = new SimpleXMLElement('<rss version="2.0"></rss>');
 
//  Create the channel element, a child of RSS
$channel = $xml->addChild('channel');
 
//  Add random channel information
$channel->addChild('title', 'Random Quotes');
$channel->addChild('link', 'http://www.earn-web-cash.com');
$channel->addChild('description', 'This is a feed of random, interesting quotes.');
$channel->addChild('pubDate', date("D, d M Y H:i:s T"));
 
//  Loop through and create item elements
foreach ($items as $item) {
  $newItem = $channel->addChild('item');
  $newItem->addChild('title', $item['title']);
  $newItem->addChild('description', $item['description']);
}
 
//  Output
header('Content-Type: application/xhtml+xml');
echo $xml->asXML();

]]> http://www.earn-web-cash.com/2008/02/21/create-rss-feed-simplexml/feed/ 5 http://www.earn-web-cash.com/2008/02/15/xml-attributes-php/ http://www.earn-web-cash.com/2008/02/15/xml-attributes-php/#comments Fri, 15 Feb 2008 19:29:49 +0000 Walkere http://www.earn-web-cash.com/2008/02/15/xml-attributes-php/ A user on Programming Talk had a problem the other day. He was trying to build an XML parser to work with an xml data file (a character sheet from the WoW Armory).

His parser wasn’t working – because all of the information was stored in attributes instead of child elements. What’s the difference between the two? And how can we fix it?

Use SimpleXML.


Difference Between a Child and an Attribute

For starters, let’s take a look at a sample XML file. This will help illustrate the difference between a child element and an attribute, and it will give us something to work with later on.

<?xml version="1.0" encoding="UTF-8"?>
 
<library>
  <book lang="en">
    <author>John Steinback</author>
    <title>Of Mice and Men</title>
  </book>
 
  <book lang="en">
    <author>F. Scott Fitzgerald</author>
    <title>The Great Gatsby</title>
  </book>  
</library>

This simple XML file is a “library.” It contains a list of books – each of which has an author, a title, and a “lang” attribute.

In this example, “book” is an element. It is a child element of library – which means it is an element created inside the open library element. You could also refer to the library element as the parent of all the book elements.

To create a child element, you simply create a set of tags within a larger set of tags. The book is a child of library, while the author is a child of book. We could create more children for “Author” – like age, sex, and hair color.

By contrast, “lang” is an attribute. It is defined inside the opening tag of an element. By declaring lang="en" we are saying that the book has the attribute of being written in English.

It is simply another (perhaps more annoying) way to store information in an XML file. Most basic XML parsers look for tags and content – but the attribute is neither. It’s contained inside a tag, so it needs to be handled specially.

Thankfully, SimpleXML is designed to help us do just that.

Loading the File in SimpleXML

I saved the xml file above in “xmltest.xml.” In my php script, I can load it into a SimpleXML object with this function call.

$xml = simplexml_load_file('xmltest.xml');

This creates a SimpleXML object which is a tree of connected objects. The root object represents the “library” element. It then has an array of children called “book,” and each “book” element has two children element of its own.

Using the SimpleXML object structure, we can access some pieces of our XML document like this.

var_dump($xml->book[0]); //  All of the info in Book 1
echo $xml->book[0]->author; // First book, John Steinbeck
echo $xml->book[1]->title; // Second book, The Great Gatsby

Accessing the Lang Attribute in the Object Tree

The initial question now resurfaces – how do we access an attribute, like the ‘lang’ attribute?

All of the elements are nicely arranged in a tree. The parent element has a child element, which has a child element, so on and so forth. We can easily access these as related objects like we did above.

The attributes are exploded into an array and attached to the element that they define. So, for example, we defined a ‘lang’ attribute for our book element. Therefore, the value of lang will reside in an array attached to that specific book element.

We can access it like this.

echo $xml->book[0]['lang']; // en

To find an attribute of an object with SimpleXML, you navigate to the element in question and then access an array indexed by the names of the attributes. In this case, our attribute was named ‘lang’ so we use ‘lang’ as a key in the array to get the value.

For simplicity’s sake, it is usually better to define all of your XML data as child elements. This allows you to easily expand data types in the future, and you won’t have to mix methods for accessing the data.

However, if you’re working with someone else’s XML file, you may need to look up attributes. Now you know how.

]]> http://www.earn-web-cash.com/2008/02/15/xml-attributes-php/feed/ 7 http://www.earn-web-cash.com/2008/02/14/create-rss-feed-php/ http://www.earn-web-cash.com/2008/02/14/create-rss-feed-php/#comments Thu, 14 Feb 2008 23:31:48 +0000 Walkere http://www.earn-web-cash.com/2008/02/14/create-rss-feed-php/ Note: If you look around the site, you may have noticed that I haven’t updated this place in a long time. Check out my new project, which is more closely focused on photography. I still discuss some design issues, though, like these free InDesign templates. If you’re looking for a camera, check out this post on the differences between entry level Canon dSLR cameras.

Or, take a look at my photography studio’s website. Along with photography, we offer a handful of design and printing services, mostly for models, actors, and fashion designers. Our newest offering is the design and printing of modeling/acting comp cards, which start at $60 for a set.

Most blogging platforms come with built-in support for RSS feeds. Why? It’s a great way for users to keep up to date on your new content. Instead of loading up a dozen favorite sites, they can look at one feed reader and then decide what to pursue further.

So what if you don’t use a blogging platform or CMS that creates a feed for you? You can create one yourself in PHP. It’s pretty simple.


Elements of an RSS 2.0 Feed

There are pretty strict standards about RSS feeds – intended to make it easier for readers to parse and display the information. Before we dive into building a feed, we should look at what it should contain. You can read the full spec at feedvalidator.

An RSS 2.0 Feed is a special type of XML file. The first things you’ll need in your file is an xml declaration, and an opening/closing RSS tag. Like this.

<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
  //  Feed elements here
</rss>

Inside the opening rss tag, you can also include any namespaces that you’ll be using. That’s a bit more than we need to worry about at the moment, though.

Inside the rss tag, you need to create a channel tag. This holds all of the individual articles as well as some basic information about the feed. You’re required to create a title, link, and description tag. You can add a lot of optional tags, of which the lastBuildDate tag would be most useful.

A basic channel declaration would look something like this.

<channel>
   <title>My Wonderful Blog</title>
   <link>http://mydomain.com</link>
   <description>This is a feed of the latest articles at My Wonderful Blog.</title>
   <lastBuildDate>Thu, 14 Feb 2008 10:57:05 GMT</lastBuildDate>
 
   //  Include individual articles here
</channel>

Finally, you can include the individual articles inside of this channel tag. Each article is represented by an item tag and a series of optional tags. Some good tags to use for a basic feed would be title, link, description, and pubDate. Like this…

   <item>
      <title>My Latest Article</title>
      <link>http://mydomain.com/latestarticle.php</link>
      <description>This is the latest cool article at my wonderful blog.</description>
      <pubDate>Thu, 14 Feb 2008 10:57:05 GMT</pubDate>
   </item>

Using PHP to Create the RSS Feed

Now that we know what goes in to an RSS feed, we can worry about how to create one.

There are several approaches we can take here. We could have PHP dynamically output an RSS feed every time the file is accessed. We could create a SimpleXML object and write it to a file each time a new article is added. Or we could simply create a string and write it to an xml file.

We’ll take the third approach. This means we need to do three things.

• Fetch the data from the database
• Build the xml formatted string
• Write the xml data to a file

Fetch the Data from the Database

This will vary depending on the database type you’re using and how it’s set up. If you’ve gotten this far in creating a dynamic, PHP-driven site, I’m sure you can figure out how to fetch information for your own database.

For the purpose of this tutorial, we’ll fetch information from a mySQL database. The database will hold the title, link, description, and pubDate of each article.

$query = "SELECT title, link, description, pubDate FROM
   articles LIMIT 10";
$result = mysql_query($query);

Note: I only retrieved the last 10 entries. There is no strict limit to the number of entries an RSS 2.0 feed can have, but it’s polite to leave it small. If they want to read every article, they’ll come to your site.

Building the XML Formatted String

Now, we need to create a blank string, format it like an XML file, loop through the mySQL result array, and insert the data into the XML file.

First, we’ll add the xml declaration, the rss tag, the channel tag, and the channel info. Then we can loop through the result set and create one item tag for each article.

$xmlString = '<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
<channel>
   <title>My Wonderful Blog</title>
   <link>http://mydomain.com/</link>
   <description>Latest articles at My Wonderful Blog.</description>
   <lastBuildDate>' . date("D, d M Y H:i:s e") . '</lastBuildDate>
 
';
 
while ($row = mysql_fetch_array($result)) {
$xmlString .= '   <item>
      <title>' . $row['title'] . '</title>
      <link>' . $row['link'] . '</link>
      <description>' . $row['description'] . '</description>
      <pubDate>' . date("D, d M Y H:i:s e", $row['pubDate'] . '</pubDate>
   </item>
';
}
 
$xmlString .= '</channel>
</rss>';

Most of that should be self-explanatory. Where I added a newline before ending the string, I was simply adding white space to make the source code more readable. This isn’t necessary – but I like neat, readable source code.

$xmlString is being created in the beginning. Then, the additional strings are appended to it with the .= operator.

The one important thing to note here is date("D, d M Y H:i:s e"). This is PHP’s function to create a formatted date. The characters inside the string determine how the timestamp is formatted.

This format is the standard required by RSS 2.0 feeds. You could simply copy and paste this string to format your dates. “D, d M Y” creates something like “Thu, 14 Feb 2008.” “H:i:s” creates the time as “18:23:30.” “e” is a representation of the timezone – which should be GMT.

Write the String to an XML File

Finally, we need to write this string to an xml file. For simplicity’s sake, we’ll call this “feed.xml” and place it in the same directory as our script.

You could use a few functions to do the file-writing. In this case, file_put_contents would be simplest – all we need to do is dump the contents of the string into a file and overwrite any previous contents.

$filename = "feed.xml";
file_put_contents($filename, $xmlString);

Now you just need to incorporate this into your existing site. You could make this a standalone script and access it every time you add new content to your site.

Or, if you’re using some kind of home-brewed CMS, you could wrap this in a function and call it right after you save the content of a new article.

Besides creating a custom feed for your own website, there are some other uses for this. You could use it to create a feed of articles from diverse sources around the internet.

If you write at a variety of sites – like Helium, Associated Content, and Xomba – you can use this to create a unified feed. Or, you could create a feed of only select articles from one of those sources. You could also create a feed of simple data – not articles – like quotes, jokes, tips, etc.

]]> http://www.earn-web-cash.com/2008/02/14/create-rss-feed-php/feed/ 33 http://www.earn-web-cash.com/2008/02/10/new-php-class-length/ http://www.earn-web-cash.com/2008/02/10/new-php-class-length/#comments Sun, 10 Feb 2008 21:42:02 +0000 Walkere http://www.earn-web-cash.com/2008/02/10/new-php-class-length/ I was looking for a project to tackle today, and I decided to make a script that would convert lengths from one unit or system to another.

It doesn’t sound all that complicated – and it’s not. I had a working script in a few minutes, but I didn’t like it. It had too many functions to do conversions for individual units. I wanted this script to be pretty well abstracted so that I could easily add new unit types – and so that the source code for the class would be very short.

You can see what I came up with at the PHP Length Conversion Class page.

The Concept Behind the Class

Here’s the concept I came up with to help standardize the class, make the code manage-able, and make it adaptable.

First, when the length class is constructed the unit of length is converted to meters. By having a standard format, it cuts down a lot on the number of conversions I need to worry about. Although it means that each value will be converted twice (from the original into meters and then from meters into the next), it cuts down a lot on overhead.

Originally, I had written functions to convert from one type to meters and vice versa. This was fine when I just had five data types, but I could see it would quickly get out of hand – and it would be tough to add new unit types.

I decided that I needed a data file (or a hard-coded data array in the class). I came up with a format for an xml file that holds all the pertinent information – the abbreviation and the ratio of the unit type to meters.

Now, the class can read the XML file, create an array of available data types, and quickly convert between one unit type and another. This enabled me to standardize the class methods – so now it only contains a handful of methods.

It could use some robustness in the way of data checking and error reporting – but for the moment I’m assuming the implementer checks that the data being passed to the class is the proper type.

]]> http://www.earn-web-cash.com/2008/02/10/new-php-class-length/feed/ 3 http://www.earn-web-cash.com/2008/02/09/modify-widget-nofollow/ http://www.earn-web-cash.com/2008/02/09/modify-widget-nofollow/#comments Sun, 10 Feb 2008 00:34:11 +0000 Walkere http://www.earn-web-cash.com/2008/02/09/modify-widget-nofollow/ I just added an RSS feed widget to my site (see the lower right corner – the DZone links). I frequent dZone a decent amount, and I find a lot of the articles interesting.

However, after some thought I became concerned that ten sitewide external links might be a bit of a drain on my pagerank. If only I could add “rel=nofollow” to all those links. But there’s no option in the RSS Widget to do that.

Well, I decided to dive in and fix it myself.

Where the RSS Feed Widget is Located

This is actually a very simple hack to the WordPress source files. You’ll need to edit two lines of the file, upload it, and you should be good to go.

The file we’re looking for is “widgets.php” – it should be located in the wp-includes folder. This holds all the functions related to creating widgets and it also holds the standard widgets available in the Dashboard.

We need to scroll down, find the “RSS Feed Widget,” find where the links are created, and add “rel=’nofollow’” to those anchor tags.

Hack It Up – Add Some Code

The function we’re looking for should be around line 935 – titled “wp_widget_rss.” Once you’ve found the function, look for this line – it should be around 965.

$title = "<a class='rsswidget' href='$url' title='" . 
  attribute_escape(__('Syndicate this content')) ."'><img 
  style='background:orange;color:white;border:none;' 
  width='14' height='14' src='$icon' alt='RSS' /></a> 
  <a class='rsswidget' href='$link' title='$desc'>$title</a>";

This creates the “RSS Icon” link to the original feed. There’s a second link in there that makes the link for the title of the RSS feed. To make these nofollow, simply add the phrase rel='nofollow' right after the <a. Be sure to use single quotes around the nofollow – or else you’ll break the PHP statement and cause an error.

When complete, it should look like this. Notice that we’re adding rel=’nofollow’ in two places.

$title = "<a rel='nofollow' class='rsswidget' href='$url' title='" . 
  attribute_escape(__('Syndicate this content')) ."'><img 
  style='background:orange;color:white;border:none;' 
  width='14' height='14' src='$icon' alt='RSS' /></a> 
  <a rel='nofollow' class='rsswidget' href='$link' title='$desc'>$title</a>";

Now scroll down a bit more to roughly line 990. The line we’re looking for creates the individual links to the articles. You should see this bit of code.

echo "<li><a class='rsswidget' href='$link'
  title='$desc'>$title</a>$summary</li>";

Again, add rel='nofollow' right after the <a. The result should look like this.

echo "<li><a rel='nofollow' class='rsswidget' href='$link'
  title='$desc'>$title</a>$summary</li>";

Upload the File

That’s it. Those two small changes should make your RSS Widgets nofollow from now on – preserving your pagerank.

Simply upload the file to the server (be sure to replace the old wp-includes/widgets.php) and reload your site.

If you run into an error, double check that you used single quotes around the ‘nofollow.’ The PHP string is started with a double quote (“), so if you place a double-quote there you’ll prematurely end the string – and cause a parse error.

]]> http://www.earn-web-cash.com/2008/02/09/modify-widget-nofollow/feed/ 15 http://www.earn-web-cash.com/2008/02/09/simple-xml-rss-feed/ http://www.earn-web-cash.com/2008/02/09/simple-xml-rss-feed/#comments Sat, 09 Feb 2008 23:53:58 +0000 Walkere http://www.earn-web-cash.com/2008/02/09/simple-xml-rss-feed/ Practically every site today has an RSS feed. Now, you could be like everyone else and simply use this as a way to read information as it’s published.

Or, you could use RSS for what’s intended for – content syndication. With Simple XML, it’s a piece of cake to use an RSS feed to add a list of links to relevant articles on your page.


What Are RSS Feeds and XML Files?

Hopefully you know what an XML file and an RSS feed is. If not, here’s the quick and dirty explanation.

An XML file is a special way to store information. All of the information is wrapped in tags – kind of like HTML. However, instead of using this to format the output, this is used to tell the reader what the information means.

So, for example, a <link> tag would probably describe a link.

XML was created to allow information to be easily ported between platforms and systems. An RSS feed is a special type of XML file to help reach that goal. Most websites (including almost all blogs), publish an RSS feed that is simply an XML file containing the latest few entries on the website.

An RSS feed also has a standard structure – which is why we can easily build a script that can parse any valid RSS feed and add the links to your site.

Getting Started with Simple XML

Before SimpleXML, you had to build your own XML parser to work with PHP and XML files. This was possible, but it meant a lot of overhead – so it wasn’t a good idea for small projects.

With SimpleXML, you can load any XML file into PHP as a specially structured object. The object’s structure mirrors the XML file. So, if there’s a <item> tag, it creates an object with name “item.” It then creates children objects of every tag inside that item tag.

To load an XML file into a SimpleXML object, you simply use this function call. Run this entire script to see what the SimpleXML object looks like after it’s loaded.

$filename = "http://www.dzone.com/links/feed/frontpage/rss.xml";
//  That's the DZone RSS Feed
 
$feed = simplexml_load_file($filename);
var_dump($feed);

What’s In an RSS Feed, and How Do We Use It?

If you ran that script, you should see the guts of an RSS feed. I’d suggest you view the source code of the output page, since it’ll be formatted nicely for you.

Like I mentioned before, RSS feeds have a standard structure so that apps can predictably interact with them. This is the basic structure you should see inside the DZone RSS feed.

//  Some random stuff up top
<channel>  // This parent tag holds all the page information
  <item>  //  There's one item per page listed in the feed
    <title> ... </title>
    <link> ... </link>
    <description> ... </description>
    <pubDate> ... </pubDate>
  </item>
  //  You could have a lot more <item> tags here
</channel>

All of this information is nicely placed in our SimpleXML object for us to manipulate.

The entire channel (all of the children tags inside the channel tag) is stored in the ‘channel’ object, which is a child of the larger ‘feed’ object that we created earlier ($feed).

You can access the channel like this.

var_dump ($feed->channel);

If there were multiple channels, then ‘channel’ wouldn’t be a single object – it would be an array of objects. This is the case with the ‘item’ tags. There are a lot of items, so they are stored in an array – which is a child object of the ‘channel.’

You can access the items like this.

var_dump ($feed->channel->item[n]);

Finally, the individual item holds most of the information we want. It has children named ‘pubDate,’ ‘title,’ and ‘link’ (along with a few other optional parameters).

echo $feed->channel->item[0]->title;
echo $feed->channel->item[0]->link;
echo $feed->channel->item[0]->pubDate;

So How Is This Useful to Us?

As you may have noticed, each item consists of the information you need to make a link back to it. The item consists of a title, a URL, a pubDate, and a description. You could use any combination of these that you feel is useful – but here’s an example of how to create a link to an article.

echo '<a href="' . $feed->channel->item[0]->link . '">' .
  $feed->channel->item[0]->title . '</a>';

And that’s all there is to it. You could spruce it up by adding a date underneath the link. Or you could add a short excerpt of the description.

What If I Want to Include All of the Links?

I suppose adding one link is kind of silly. With a loop, we can easily iterate through the item[] array and output a link for every item in the RSS feed.

For good measure, we’ll also format it nicely in an unordered list. From there, you can add some styling and it’ll fit right into the sidebar of your page.

//  Load the XML file into a Simple XML object
$filename = "http://www.dzone.com/links/feed/frontpage/rss.xml";
$feed = simplexml_load_file($filename);
 
//  Iterate through the list and create the ul
echo "<ul>";
foreach ($feed->channel->item as $item) {
  echo "<li><a href='" . $item->link . "'>" .
    $item->title . "</a></li>";
}
echo "</ul>";

There ya have it. A semantically structured list, built from a remote RSS feed. All in a couple lines of code.

You could of course separate this out into a function, and then pass a filename (and perhaps a limiting # of items to print) to your function. The function would return a string with the html list, or output it directly (depending on your preference).

Word of Caution: Remember that you don’t own content just because it is published in an RSS feed. The author still does.

I would assume that it’s fair game and free of copyright issues to print links to the original author’s site. However, some authors publish their entire articles in their RSS feeds. Do not re-publish the entire article. That is copyright infringement, it is illegal, and you can get in a lot of trouble. Not to mention it’s highly unethical.

With that in mind, happy syndicating!

]]> http://www.earn-web-cash.com/2008/02/09/simple-xml-rss-feed/feed/ 34 http://www.earn-web-cash.com/2008/02/08/multi-page-form-revisted/ http://www.earn-web-cash.com/2008/02/08/multi-page-form-revisted/#comments Sat, 09 Feb 2008 00:59:26 +0000 Walkere http://www.earn-web-cash.com/2008/02/08/multi-page-form-revisted/ A couple weeks ago, I wrote a short article about how to create a multi-page form.

The simple solution I suggested involved a foreach loop that cycled through the $_POST array and sent every value along in a hidden input element. After a bit of reflection (and some useful comments), I realized there’s a teeny tiny security hole in that approach – so I’ve slightly modified it to close the loophole.


The Multi-Page Form Snippet

The old snippet of code looked like this…

foreach ($_POST as $key => $val) {
  echo '<input type="hidden" name="' . $key . 
    '" value="' . $val . '" />' . "\r\n";
}

The Security Loophole

What’s the problem? If someone enters a quote into the form, it could break all of the hidden elements. Here’s an example.

Let’s say I type this into a text input.

" /><input type="text" name="newField" value="newValue

The next page would create this…

<input type="hidden" name="firstField" value="" />
<input type="text" name="newField" value="newValue" />

By adding a quote, you prematurely end the first hidden element and can add new html tags. You can combine this with javascript for some potentially nasty effects. I guess. I’m really not sure what you could do with this… but it’s better to be safe than sorry, eh?

How to Fix the Multi-Page Form Snippet

We can close this loophole once and for all with a simple function call – htmlentities. With the proper parameter, this will encode all html entity characters (including quotes), so that the user can’t input a quote or create new HTML tags.

foreach ($_POST as $key => $val) {
  echo '<input type="hidden" name="' . $key . '" value="' 
    . htmlentities($val, ENT_QUOTES) . '" />' . "\r\n";
}

No more problems.

It’s also important to note that this problem isn’t just a security loophole. By not validating the input before creating the hidden element, you could accidentally break the form for a legitimate user. If the user enters a ” inside a text field, it would break the hidden element on the next page.

Why Not Use Sessions or a Database?

Some people have suggested using sessions or a database to accomplish the same thing. That’s certainly possible, but I feel this is a better design choice.

I like to keep the php and html as separate as possible. This allows us to keep all of the input inside of the form until we’re ready to process it. Meanwhile, our processing script sees all of the input as coming from a single form – even if it came from different pages.

By contrast, you need to break up your processing script to use databases. You also need to mix and match $_POST and $_SESSION to use sessions to store the information. It’s functional, but doesn’t seem elegant to me.

With that in mind, this is something of a preference. It’s not better than the other methods – but I think it is semantically more logical. So use what you prefer.

]]> http://www.earn-web-cash.com/2008/02/08/multi-page-form-revisted/feed/ 3 http://www.earn-web-cash.com/2008/02/01/gimp-tutorials/ http://www.earn-web-cash.com/2008/02/01/gimp-tutorials/#comments Fri, 01 Feb 2008 23:09:10 +0000 Walkere http://www.earn-web-cash.com/2008/02/01/gimp-tutorials/ burst of traffic with each new listing. Another site I've found useful is Gimp Tutorials. They're a great place to list any graphics tutorials that you write for the GIMP graphic design program.]]> If you write tutorials on your website or blog, then niche tutorial directories are a great source of traffic. I list most of my php tutorials with good-tutorials and get a nice burst of traffic with each new listing.

Another site I’ve found useful is Gimp Tutorials. They’re a great place to list any graphics tutorials that you write for the GIMP graphic design program.

In case you don’t know what GIMP is, head to the Gimp homepage. It’s a free, open source graphic editing suite – similar in many ways to the expensive, proprietary Adobe Photoshop.

Gimp Tutorials is another niche directory where you can submit appropriate tutorials for listing. In this case, appropriate means just about anything related to creating or editing an image in Gimp.

I wrote a very basic tutorial to show users how to create a gradient background image in GIMP. Since I submitted the tutorial to Gimp Tutorials, slightly less than week ago, they’ve sent me 200 visits.

There was a brief spike on the first day, and I’ve been getting a steady stream of 20-30 visitors each day after that.

There doesn’t appear to be a lot of turnover on the site, so my tutorial is still listed third on the front page. That’s after five days. That’s a pretty lengthy period of exposure – considering that others sites (like Good Tutorials) turnover in about a day.

So if you write any tutorials for GIMP, don’t hesitate to submit them here. It’s a good way to drive a few extra users to your latest article.

]]> http://www.earn-web-cash.com/2008/02/01/gimp-tutorials/feed/ 0