@scriptnode

Should be:

@<href="http://twitter.com/scriptnode">scriptnode</a>

Which looks like:

@scriptnode

And here’s how to do it in PHP and JavaScript:

PHP

<br /> $text = preg_replace(’#@([a-z0-9_]+)#i’, ‘@<a href=”http://twitter.com/\\1″>\\1</a>’, $text);<br />

That was easy! Now let’s get to the more interesting JavaScript, which allows us to test inline!

JavaScript

<br /> text = text.replace(/@([a-z0-9_]+)/gi, ‘@<a href=”http://twitter.com/$1″>$1</a>’);<br />

You can run this code right here:

Format

I’m awful at regular expressions; please do let me know if I could optimize somewhere or if I missed something.
Edit: + instead of *

But time is a commodity nowadays. I’ve got way less time to write, and when I do, I’d rather be writing code than tutorials (or honestly, playing video games). Sorry about that, but I hope the (well-commented!) source will help those of you out there who’d like to contribute to the slowly growing world of DHTML games.

You’ll notice that this code is over 6 months old. And I’m the kind of developer who constantly updates his style, methods and patterns. Given that, there may very well be many mistakes or bad practices in here, some of which I may have improved upon by now, but others maybe not. Either way, feel free to comment on them, and I’ll answer any questions as well.

Thanks for checking it out, and please be good to it. I’d love to know about any projects created with this source as a basis, and would appreciate links back here. Also please don’t claim it as your own, that’s not cool.

Enjoy!

Say you’ve got a fancy user interface. You’re leveraging AJAX well, you’re making good use of best practices, and you’ve got fast servers that respond quickly.
But your user actions still aren’t quite as fast as you’d like. What else can you do?

If you’ve done things correctly, you’ve got a user interface that reacts positively to successful flows, but will also handle errors gracefully.
Even though you’re “doing it right,” consider restructuring your application: assume success. Normally, your server is up and running and operations
will be completely successfully. The edge case (hopefully) is the error case. Assuming this, we can create a slightly faster user interface.

Let’s begin with a basic voting mechanism. You’ve got a control on your page that lets a user vote on an object, and a small bit of text to represent the state of said control.
It may look something like this:

This example is meant to be easy and functional; hopefully your controls are prettier.
Regardless, here’s a common flow for this request and its callback states:

1. Listen for the click event on the control.
2. Send the request.
3. Display a “loading” message or a typical spinner image.
4. If the call comes back successfully, provide “success” feedback to the user and update the control.
5. If the call throws an error, provide an error message.

This flow is extremely common in today’s web. But we want something more immediately responsive, so let’s restructure the flow:

1. Use onmousedown because it will fire off just slightly sooner than onclick would.
   (This might not suit all user interfaces but in this case it’s fine, and it wins us a few milliseconds.)
2. Provide “success” feedback to the user and update the control.
3. Send the request.
4. If the call throws an error, reset the controls and provide an error message.

This structure might seem a little off. Indeed, the error case even “lies” to the user for a few milliseconds if the request fails.
But it covers all of its bases; none of the previous flow is omitted.
Keep in mind that the error case is the edge case, and a very large majority of the time it’s fine to assume success at first.

Using jQuery, here’s what the code might look like:

<br /> // Attach the mousedown event listener<br /> $(’#snappier-1-btn’).mousedown(function(e) {</p> <p> var el = $(this);</p> <p> // Go ahead and assume things went smoothly<br /> el.attr(’disabled’, true);<br /> el.next().html(’Voted!’);</p> <p> // Send the XHR<br /> $.ajax({<br /> error : function() {</p> <p> // Undo the success message and allow the user to repeat<br /> el.attr(’disabled’, false);<br /> el.next().html(”You haven’t voted yet”);</p> <p> // Let the user know what happened<br /> alert(”Sorry, an error occurred! Please try again.”);</p> <p> },<br /> type : ‘GET’,<br /> url : ‘/feed/’<br /> });</p> <p>});<br />

And here’s this flow working right here on the page:

I often see questions similar to, “I’ve got these few lines of PHP code, how would I do this in JavaScript?” I’ve actually already answered a question like this, but I kept getting more questions, so I thought I’d cover many at once:

• Pushing to an array
• die() or exit
• include or require
• Redirection
• Static classes
• String manipulation

Pushing to an array

Pushing a new value to the end of an array is a common, trivial task. Here’s some PHP to accomplish this:

<br /> $my_array = array();<br /> $my_array[] = ‘a’;<br /> array_push($my_array, ‘b’);<br />

Also note this quick pointer from php.net’s array_push() documentation:

If you use array_push() to add one element to the array it’s better to use $array[] = because in that way there is no overhead of calling a function.

This isn’t the case in JavaScript. The native Array.push method is most optimal:

<br /> var myArray = [];<br /> myArray.push(’a'); // This is the way to go<br /> myArray[myArray.length] = ‘b’; // This method is possible but bad<br />

die() or exit

There has been much confusion regarding what JavaScript is and how it works in the browser. When looking for an equivalent to exit, one probably doesn’t understand that client-side JavaScript is a behavioral language that’s intended to react to events. In PHP, a script executes, stopping only when told to do so, and then it’s done. JavaScript lives and breathes on the page, reacting to the mouse being moved, keys being pressed and even time changing.

So it’s important to understand why this is not a fair equivalent, and that even asking for one shows a misunderstanding. That said, a bit of procedural JavaScript can be exited by using an anonymous function. Here’s some example PHP and then similar code in JavaScript:

<br /> if ($next_action == ‘exit’) {<br /> exit;<br /> }</p> <p>echo ‘Made it here!’;<br />

<br /> (function() {</p> <p> if (nextAction == ‘exit’) {<br /> return;<br /> }</p> <p> alert(’Made it here!’);</p> <p>})();<br />

While the language behavior is not one-to-one, taking advantage of JavaScript’s closure already has advantages, among them being able to easily exit a function via return.

include or require

There have been some arguments about this equivalence in JavaScript. Just like the previous example, this equivalence is not one-to-one and should be thought about in very different terms. That said, here is a quick example of including a PHP file within a PHP script:

<br /> // Nothing to it, just include the file:<br /> include(’my_file.php’);</p> <p>// This code will only execute after my_file.php has been included:<br /> echo ‘File included!’;<br />

To include an external script in JavaScript, writing a method or including a library is definitely best. I wrote about this once, but there are libraries such as YUI that have better support with more options. Here’s what this would look like using YUI:

<br /> // Call YUI’s method<br /> var objTransaction = YAHOO.util.Get.script(”http://example.com/my_file.js”, {<br /> // This function will only fire after my-file.js has been included:<br /> onSuccess : function() {<br /> alert(”File included!”);<br /> }<br /> });<br />

Redirection

This one is easy and straightforward. A redirect is accomplished with PHP’s header() function:

<br /> header(’Location: http://example.com’);<br /> exit; // Not necessary but a good practice<br />

Also very simple in JavaScript:

<br /> location.href = ‘http://example.com’;<br />

Static classes

In PHP, it’s a pretty common programming pattern to use a static class for encapsulation, sort of namespacing some methods and properties. Here’s an example:

<br /> class Tools {</p> <p> public static function check_stuff() {<br /> return true;<br /> }</p> <p>}</p> <p>echo Tools::check_stuff();<br />

For this JavaScript equivalence, it probably makes the most sense to use an object literal:

<br /> Tools = {<br /> checkStuff : function() {<br /> return true;<br /> }<br /> };</p> <p>alert(Tools.checkStuff());<br />

String manipulation

String manipulation is absolutely mandatory in most applications. Fortunately, it’s a breeze thanks to PHP’s fantastic string functions:

<br /> // Replace portions within a string<br /> echo str_replace(’Hey’, ‘Hi’, ‘Hey there’); // outputs “Hi there”</p> <p>// Capitalization<br /> echo strtolower(’Hey there’); // outputs “hey there”<br /> echo strtoupper(’Hey there’); // outputs “HEY THERE”</p> <p>// Get a portion of a string<br /> echo substr(’Hey there’, 0, 2); // outputs “He”</p> <p>// Get rid of extraneous whitespace<br /> echo trim(’     Hey there     ’); // outputs “Hey there”<br />

Each of these have perfect equivalents except for trim(), which we need to implement ourselves:

<br /> // Replace portions within a string<br /> alert(’Hey there’.replace(’Hey’, ‘Hi’)); // outputs “Hi there”</p> <p>// Capitalization<br /> alert(’Hey there’.toLowerCase()); // outputs “hey there”<br /> alert(’Hey there’.toUpperCase()); // outputs “HEY THERE”</p> <p>// Get a portion of a string<br /> alert(’Hey there’.substr(0, 2)); // outputs “He”</p> <p>// Get rid of extraneous whitespace<br /> trim = function(txt) {<br /> return txt.replace(/^\s+|\s+$/g, ”);<br /> };</p> <p>alert(trim(’     Hey there     ’)); // outputs “Hey there”</p> <p>

Or, we can augment the String global so that strings will have this method natively:

<br /> String.prototype.trim = function() {<br /> return this.replace(/^\s+|\s+$/g, ”);<br /> };</p> <p>// Get rid of extraneous whitespace<br /> alert(’     Hey there     ’.trim()); // outputs “Hey there”<br />

While not all of these equivalents are smooth (or even recommended), it’s typically helpful when learning a new language to have it compared to a language one is already familiar with. If you can think of any other common PHP tasks that have relatively similar equivalents in JavaScript, please let me know in the comments.

<br /> $my_string = “This string\n”;<br /> $my_string .= “spans multiple\n”;<br /> $my_string .= “lines.\n”;<br />

Thankfully, PHP has the benefit of heredoc syntax, which makes code like this much easier to read, write and maintain:

<br /> $my_string = <<<MYSTRING<br /> This string<br /> spans multiple<br /> lines.<br /> MYSTRING;<br />

E4X

But what about JavaScript? There is no native heredoc support, but there are some other workarounds that can be used. The first I’ll offer up is ECMAScript for XML (E4X).

<br /> var myString = ” + <myString><![CDATA[This string<br /> spans multiple<br /> lines.<br /> ]]></myString>;<br />

The first line in the above example is a bit confusing. The XML will return an xml object by default, but what we want is a String. We can type the return as a String by concatenating to an empty string ('').

Next, an element must be wrapped around the CDATA to trigger the XML parser. This step is similar to PHP’s heredoc syntax in that it requires an identical beginning and ending identifier.

You can test this yourself in the lab.
Currently, it looks like only Gecko browsers (such as Firefox and Camino) support E4X. This obviously doesn’t include Internet Explorer, which is (unfortunately) often a large portion of most websites’ user bases. While this workaround is interesting, it’s definitely not realistic to assume all of your users are using Firefox, despite its rising popularity (also, it will fail to validate).

Hidden Element Hack

Another workaround I’ve seen is to place the string inside of an element (often hidden from view) and to read it in via JavaScript. Here’s an example:

<br /> /* Based on this markup:<br /> <div id=”multilines” style=”display: none;”><br /> This string<br /> spans multiple<br /> lines.<br /> </div><br /> */<br /> var myString = document.getElementById(’multilines’);<br />

This solution is clever, but definitely a hack job: not very clean, and with a bad accessibility case. The primary issue though is that it doesn’t completely solve the problem. Markup is needed to interact with the JavaScript code, so to use this solution one couldn’t maintain a completely independent .js file.

Escaping linebreaks

Another solution is very simply just to escape line breaks:

<br /> var myString = “This string\<br /> spans multiple\<br /> lines.”;<br />

By escaping the linebreak, you’re free to continue the string on the next line (note: this doesn’t include spaces, so if you want to separate words, you’ll need to begin each new line with a space). This solution is not as attractive as the E4X workaround, but has the benefit of being perfectly cross-browser compatible. Therefore, it looks like it’s currently the best method available.

Do you know of any other workarounds? If so, please let me know in the comments section.

<br /> myArray.push(thevalue);<br />

Easy stuff. What’s unfortunate, though, is when the questions are a bit more involved, and these developers have already searched around a bit and found lousy code to read and learn from. The problem is that there’s much ancient, awful JavaScript code out there, and when performing simple search queries, these sites come up. My goal is to improve this process.

One common topic is that of cookies. Dealing with cookies is really basic stuff, but hey, that’s what the novice category is for. So here’s a simple script to assist with managing cookies:

<br /> /**<br /> * Global cookies object to manage cookies<br /> * @return {Object} The exposed methods<br /> * @public<br /> */<br /> var cookies = (function() {</p> <p> /**<br /> * Gets a cookie’s value<br /> * @param {String} name The name of the cookie to get<br /> * @return {String} The cookie’s value, or false if it can’t find the cookie<br /> * @member cookies<br /> * @public<br /> */<br /> var get = function(name) {</p> <p> var cookie = document.cookie,<br /> end,<br /> pre = name + ‘=’,<br /> begin = cookie.indexOf(’; ‘ + pre);</p> <p> if (begin == -1) {<br /> begin = cookie.indexOf(pre);<br /> if (begin !== 0) return false;<br /> } else {<br /> begin += 2;<br /> }</p> <p> end = document.cookie.indexOf(’;', begin);<br /> if (end == -1) end = cookie.length;</p> <p> return decodeURIComponent(cookie.substring(begin + pre.length, end));</p> <p> };</p> <p> /**<br /> * Removes a cookie that has already been set<br /> * @param {String} name The name of the cookie to remove<br /> * @param {String} path The path of the cookie to remove<br /> * @param {String} domain The domain of the cookie to remove<br /> * @member cookies<br /> * @public<br /> */<br /> var remove = function(name, path, domain) {</p> <p> var cookie = name + ‘=’;</p> <p> if (!get(name)) return;<br /> if (path) cookie += ‘; path=’ + path;<br /> if (domain) cookie += ‘; domain=’ + domain;<br /> cookie += ‘; expires=Thu, 01-Jan-70 00:00:01 GMT’;</p> <p> document.cookie = cookie;</p> <p> };</p> <p> /**<br /> * Tells the browser to set a cookie<br /> * @param {String} name The name of the cookie to set<br /> * @param {String} value The value to set in the cookie<br /> * @param {String} expires The date that the cookie expires (must be a valid date string)<br /> * @param {String} path The path of the cookie to set<br /> * @param {String} domain The domain of the cookie to set<br /> * @param {Boolean} secure Whether to make the cookie secure or not<br /> * @member cookies<br /> * @public<br /> */<br /> var set = function(name, value, expires, path, domain, secure) {</p> <p> var cookie = name + ‘=’ + encodeURIComponent(value);</p> <p> if (expires) cookie += ‘; expires=’ + expires.toGMTString();<br /> if (path) cookie += ‘; path=’ + path;<br /> if (domain) cookie += ‘; domain=’ + domain;<br /> if (secure) cookie += ‘; secure’;</p> <p> document.cookie = cookie;</p> <p> };</p> <p> return {<br /> get : get,<br /> remove : remove,<br /> set : set<br /> };</p> <p>})();<br />

You can download this script below:

• [Download cookies.js] (2,160 bytes)
• [Download cookies-min.js] (634 bytes; compressed)

Also, PPK has an in-depth article about cookies. His code examples get the job done, but unfortunately create too many functions in the global scope (which, as we all know, should be avoided).

The Script

<br /> var loadCSS = function(file) {<br /> var link = document.createElement(’link’);<br /> link.href = file;<br /> link.rel = ’stylesheet’;<br /> link.type = ‘text/css’;<br /> document.getElementsByTagName(’head’)[0].appendChild(link);<br /> };</p> <p>var loadJS = function(file) {<br /> var script = document.createElement(’script’);<br /> script.src = file;<br /> script.type = ‘text/javascript’;<br /> document.getElementsByTagName(’head’)[0].appendChild(script);<br /> };<br />

Example 1 – JavaScript

First let’s load up a JavaScript file. Here’s what the external JS file looks like:

<br /> alert(’Loaded!’);<br />

And by using the above script, loading it is easy:

<br /> loadJS(’/assets/misc/dynamic-load/example-1.js’);<br />

Load JS file

Example 2 – CSS

Loading CSS is not much different. Here are the contents of the external CSS file:

<br /> body {<br /> border: 3px solid red;<br /> }<br />

Note that you can also use relative URLs or even files on another server:

<br /> loadCSS(’http://scriptnode.com/assets/misc/dynamic-load/example-2.css’);<br />

Load CSS file

This has been tested and works in all of the standard browsers including
Firefox, Chrome, Internet Explorer, Opera and Safari.

Many JavaScript libraries support the evaluating of data returned via XHR. Some, like YUI, do not (yet). In other cases, folks have rolled their own “AJAX library” but still want this behavior. The below script supports searching HTML for scripts and evaluating them:

<br /> /**<br /> * Evaluate the passed content for <script> tags<br /> * @param {String} html The string to parse<br /> */<br /> var evalHTML = function(html) {</p> <p> var piece,<br /> res = html.split(/<script/);</p> <p> res.shift();</p> <p> for (var i = 0, len = res.length; i < len; i++) {</p> <p> (piece = res[i].split(/>/)).shift();</p> <p> try {<br /> eval(piece.join(’>').split(’</scr’ + ‘ipt>’).shift());<br /> } catch (e) {}</p> <p> }</p> <p>};<br />

You can execute some examples yourself below:

<br /> // Example 1 – script inside of a div<br /> evalHTML(’<div><scr’ +<br /> ‘ipt>alert(”Hello, JavaScript!”);</scr’ +<br /> ‘ipt>’);<br />

Execute example 1

<br /> // Example 2 – script sets a global variable then displays it<br /> evalHTML(’<scr’ + ‘ipt>var foo = “bar”;</scr’ +’ipt>’ +<br /> ‘<scr’ + ‘ipt>alert(foo);</scr’ +’ipt>’);<br />

Execute example 2

• [Download eval.js] (376 bytes)
• [Download eval-min.js] (214 bytes; compressed)

Update 9/28/08: Fixed a bug thanks to Isaac Schlueter (see comments).

If you’ve had your hands in JavaScript for a while, chances are you’ve ran into this bug. You’ve got a bunch of elements you’re either adding to the
DOM or a bunch of listeners you’re attaching to elements. Either way, you keep getting the same result:
the last value in the loop. Here’s an example:

Let’s say you’ve got a list of 5 items and you want to listen to the click event for each.
Many developers would immediately think of doing it this way:

<br /> var els = document.getElementById(’last-one-example-1′).getElementsByTagName(’LI’);</p> <p>for (var i = 0; i < els.length; i++) {<br /> els[i].onclick = function() {<br /> alert(’You clicked element #’ + i);<br /> };<br /> }<br />

You can try this example below:

No matter which element is clicked, the same result keeps appearing: You clicked element #5.
This baffles many JavaScript programmers. So what’s going on here?

The issue here is a misunderstanding of closure.
In the above example, it’s assumed that the variable i will retain its value during the loop for that particular function call.
But actually what’s happening is the click function is accessing the same i variable that the for loop accessed.
So anytime i is checked, its value will be the same as it was when the loop finished.

A Solution

Usually what a developer wants to accomplish is a function listening to the click event that retains the value of
i as it was during that iteration in the loop.
Here’s a way to accomplish that behavior:

<br /> var els = document.getElementById(’last-one-example-2′).getElementsByTagName(’LI’);</p> <p>for (var i = 0; i < els.length; i++) {</p> <p> els[i].onclick = function(currentLoopValue) {<br /> return function(e) {<br /> alert(’You clicked element #’ + currentLoopValue);<br /> };<br /> }(i);</p> <p>}<br />

This pattern can be more than a little confusing. Let’s walk through it line-by-line, starting with line 5:

5. This time we’re firing off a function immediately, allowing us to run some code within a closure to avoid i changing values on us.
6. We still want the onclick to be assigned a function to fire, so we return an anonymous function just like we did before.
7. We alert the item number just like we normally would (but this time it will work).
8. End the returned function.
9. End the onclick assignment.
   This function gets fired off immediately because of the parentheses.
   We pass i in, retaining its current loop value because of the function scope we declared on line 5.
   This is probably the step that confuses developers the most.

Here is that example in action:

And it works the way you’d expect! What do you think?
If you don’t quite understand the pattern, or have another method to use to solve this problem, I’d love to hear about it in the comments.

./clh.php local-site.com/public_html/

Note: you must be root to run it

Given this command, the script will change DocumentRoot to local-site.com/public_html/ and restart apache2.
I work on a lot of websites (developing most of them on my laptop running apache2)
so I use this script constantly.

Here’s the code:

<br /> #!/usr/bin/php<br /> <?php</p> <p>/*<br /> ChangeLocalHost v0.1 – last updated Mar 07 2007<br /> Must be root to execute. Alters the DocumentRoot in Apache2’s conf file, then restarts Apache2.<br /> */</p> <p>$obj_clh = new ChangeLocalHost(’/etc/apache2/sites-available/’, ‘default’, ‘/home/www/’);</p> <p>$obj_clh->setArgs($_SERVER['argv']);<br /> $obj_clh->run();</p> <p>/**<br /> * CLH class constructor<br /> * @constructor<br /> */<br /> class ChangeLocalHost {</p> <p> private $arr_args,<br /> $bit_msgs,<br /> $str_dir,<br /> $str_file,<br /> $str_pre;</p> <p> protected $str_version;</p> <p> /**<br /> * Constructor method<br /> * @param string str_dir The location of the Apache conf file to mod<br /> * @param string str_file The name of the Apache conf file to mod<br /> * @param string str_pre The needle to search for in the conf file<br /> */<br /> function __construct($str_dir, $str_file, $str_pre) {</p> <p> $this->str_version = ‘ChangeLocalHost v0.1′;</p> <p> $this->arr_args = Array();<br /> $this->bit_msgs = true;<br /> $this->str_dir = $str_dir;<br /> $this->str_file = $str_file;<br /> $this->str_pre = $str_pre;</p> <p> }</p> <p> /**<br /> * Modify Apache’s DocumentRoot<br /> * @param string str_file The (conf) file to mod<br /> * @param string str_new_dir The new directory to set as DocumentRoot<br /> * @private<br /> */<br /> private function alterLocalHost($str_file, $str_new_dir) {</p> <p> $str_contents = file_get_contents($str_file);</p> <p> if (!$str_contents) {<br /> $this->showError(’Could not read ‘ . $str_file);<br /> }</p> <p> $int_begin = strpos($str_contents, $this->str_pre);<br /> $int_end = strpos(substr($str_contents, $int_begin), “\n”);<br /> $str_search = substr($str_contents, $int_begin, $int_end);<br /> $str_contents = str_replace($str_search, $str_new_dir, $str_contents);<br /> $bit_written = file_put_contents($str_file, $str_contents);</p> <p> if ($bit_written) {<br /> $this->showMessage(’Successfully set DocumentRoot to ‘ . $str_new_dir);<br /> } else {<br /> $this->showError(’Could not write ‘ . $str_file);<br /> }</p> <p> }</p> <p> /**<br /> * Validates the new directory to set<br /> * @param string str_new_dir The potential new directory<br /> * @private<br /> */<br /> private function checkLocalHost($str_new_dir) {</p> <p> $str_set_to = $this->str_pre . $str_new_dir;</p> <p> if (is_dir($str_set_to)) {</p> <p> $this->setLocalHost($str_set_to);<br /> $this->restartApache2();</p> <p> } else {<br /> $this->showError($str_set_to . ‘ is not a valid directory.’);<br /> }</p> <p> }</p> <p> /**<br /> * Ensures this app is being executed as root<br /> * @private<br /> */<br /> private function checkRoot() {</p> <p> // Make sure user is root<br /> $str_command = ‘whoami’;</p> <p> exec($str_command, $arr_output, $int_return);</p> <p> if ($arr_output[0] != ‘root’) {<br /> $this->showError(’You must be root to run this program.’);<br /> }</p> <p> }</p> <p> /**<br /> * Makes a backup of the Apache conf file<br /> * @param string str_source The original to copy<br /> * @param string str_new The location of the backup<br /> * @return bool Whether the copy was successful or not<br /> * @private<br /> */<br /> private function makeCopy($str_source, $str_new) {</p> <p> $bit_copy = copy($str_source, $str_new);</p> <p> if (!$bit_copy) {<br /> $this->showError(’Could not make copy of ‘ . $str_source);<br /> }</p> <p> return true;</p> <p> }</p> <p> /**<br /> * Restarts Apache2<br /> * @private<br /> */<br /> private function restartApache2() {</p> <p> $str_command = ‘apache2ctl restart’;</p> <p> exec($str_command, $arr_output, $int_return);</p> <p> if ($int_return > 0) {<br /> $this->showError(’Could not restart Apache2.’ . $str_source);<br /> }</p> <p> $this->showMessage(’Successfully restarted Apache2.’);</p> <p> }</p> <p> /**<br /> * Executes the script<br /> */<br /> function run() {</p> <p> $this->checkRoot();</p> <p> $str_new_dir = $this->arr_args[1];</p> <p> switch ($this->arr_args[1]) {</p> <p> case ‘-c’ :<br /> case ‘–current’ :<br /> $this->showCurrent();<br /> break;</p> <p> case ” :<br /> case ‘-h’ :<br /> case ‘–help’ :<br /> $this->showHelp();<br /> break;</p> <p> case ‘-q’ :<br /> case ‘–quiet’ :<br /> $str_new_dir = $this->arr_args[2];<br /> $this->bit_msgs = false;<br /> break;</p> <p> case ‘-v’ :<br /> case ‘–version’ :<br /> $this->showVersion();<br /> break;</p> <p> default :<br /> break;</p> <p> }</p> <p> $this->checkLocalHost($str_new_dir);<br /> exit(0);</p> <p> }</p> <p> /**<br /> * Create a copy of the arguments global<br /> * @param array array_args The arguments to set<br /> */<br /> function setArgs($arr_args) {<br /> $this->arr_args = &$arr_args;<br /> }</p> <p> /**<br /> * Call the other methods to initiate the altering of the DocumentRoot<br /> * @param string str_new_dir The new value of DocumentRoot<br /> * @private<br /> */<br /> private function setLocalHost($str_new_dir) {</p> <p> $str_ext = ‘.bak’;<br /> $str_file = ($this->str_dir . $this->str_file);<br /> $str_backup = $str_file . $str_ext;</p> <p> if (is_file($str_file)) {</p> <p> if ($this->makeCopy($str_file, $str_backup)) {<br /> $this->showMessage(’Copied backup of ‘ . $this->str_file . ‘ to ‘ . $this->str_file . $str_ext);<br /> }</p> <p> $this->alterLocalHost($str_file, $str_new_dir);</p> <p> } else {<br /> $this->showError($str_file . ‘ cannot be found.’);<br /> }</p> <p> }</p> <p> /**<br /> * Show what DocumentRoot is currently set to<br /> * @private<br /> */<br /> private function showCurrent() {</p> <p> $str_file = ($this->str_dir . $this->str_file);</p> <p> if (is_file($str_file)) {</p> <p> $str_contents = file_get_contents($str_file);</p> <p> if (!$str_contents) {<br /> $this->showError(’Could not read ‘ . $str_file);<br /> }</p> <p> $int_begin = strpos($str_contents, $this->str_pre);<br /> $int_end = strpos(substr($str_contents, $int_begin), “\n”);<br /> $str_search = substr($str_contents, $int_begin, $int_end);</p> <p> $this->showMessage(’The current DocumentRoot is: ‘ . $str_search);<br /> exit;</p> <p> } else {<br /> $this->showError($str_file . ‘ cannot be found.’);<br /> }</p> <p> }</p> <p> /**<br /> * Display a message and exit<br /> * @param string str_error The message to display<br /> * @private<br /> */<br /> private function showError($str_error) {</p> <p> echo ‘Error: ‘ . $str_error . “\n”;</p> <p> exit(1);</p> <p> }</p> <p> /**<br /> * Show the help text and exit<br /> * @private<br /> */<br /> private function showHelp() {</p> <p> $str_help .= ‘Usage: clh [DIRECTORY]… [OPTIONS]‘ . “\n”;<br /> $str_help .= ‘Alter the DocumentRoot in Apache2.’ . “\n”;<br /> $str_help .= “\n”;<br /> $str_help .= ‘ -c, –current display current DocumentRoot and exit’ . “\n”;<br /> $str_help .= ‘ -h, –help display this help and exit’ . “\n”;<br /> $str_help .= ‘ -q, –quiet suppress most messages’ . “\n”;<br /> $str_help .= ‘ -v, –version output version information and exit’ . “\n”;<br /> $str_help .= “\n”;<br /> $str_help .= ‘Report bugs to <scriptnode@gmail.com>.’ . “\n”; // Hahahaha</p> <p> echo $str_help;</p> <p> exit(0);</p> <p> }</p> <p> /**<br /> * Display a message to the user<br /> * @param string str_message The message to show<br /> * @private<br /> */<br /> private function showMessage($str_message) {</p> <p> if ($this->bit_msgs) {<br /> echo $str_message . “\n”;<br /> }</p> <p> }</p> <p> /**<br /> * Attempt to be more like a real application by displaying the version<br /> * @private<br /> */<br /> private function showVersion() {</p> <p> echo $this->str_version . “\n”;</p> <p> exit(0);</p> <p> }</p> <p>}<br />

You’ll notice that the script is at least a year and a half old.
Usually if code of mine is more than a year old, it’s completely unusuable because my habits change pretty often.
But I think I’ve finally gotten to that sweet spot where it’s not total garbage, it just needs tweaking.

I was surprised that the code isn’t too bad really. It’s easily readable and well organized. There are many things that I wouldn’t have done were I to write this again;
for example, I stopped using type prefixes long ago (such as an array of users as $arr_users). I understand why I used to do this, but it’s not necessary
and only clutters up the code.

Anyway, I find this script useful and I thought someone else might too. Enjoy!

• [Download clh.php.txt] (6,614 bytes)
• [Download clh.zip] (1,975 bytes)