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.

I unfortunately am not allowed to participate, but in anticipation of Yahoo!’s Hack Day 2008, I put together a little app I’ll hopefully be able to port to YAP: twittertyper!

The concept is very simple. twittertyper displays the latest tweet from Twitter. To read the next one, first type out the tweet. The text is highlighted as you go. If you come across a character your keyboard (or operating system) won’t let you type, just press Esc to move on to the next character.

twittertyper currently just pulls in from the public timeline; no authentication is supported to pull from your timeline (maybe in a future version). This mini-app is built on YUI. Source code (uncompressed) is free to peruse.

Try it out!

Note: If you use Twitter, I’m sure you’re used to it being down. Errors happen often, but twittertyper attempts to handle them somewhat gracefully. Usually a page reload should suffice.

Google is a buzzworthy company, though, and I’ve already heard from everyone and their mom about how simple, clean and (most notably), fast the browser is. This piqued my interest. Time for more benchmarks!

I really thought I’d published more benchmark articles by now, but there were only two, so amending them was quick and easy. Here are the results:

Try… Catch Benchmark

This benchmark was setup to see how quickly the standard browsers could execute code that was throwing (and catching) errors. Read the full article here.

As you can see, Chrome is among the highest performers. It executes the plain code insanely fast (never more than 1 millisecond in any of my tests), and is only second to Safari 3 in terms of catching errors quickly.

Conditional Benchmarks

This benchmark is a little more abstract. The objective was to determine which conditional is fastest among if, switch and what I call an object conditional.

Turns out, that was no fluke earlier. Chrome easily blows away the competition here. I might question Google’s motives (and I certainly think it’s a tad shady to have renewed their contract with their now-competitor and then release competing software), but I applaud their speed of my beloved JavaScript.

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.

When modifying the framework I had built, I noticed that the old database class I was using was a little out of date. PHP5 is the new standard, shouldn’t we all
be using PDO? So I added migrating to PDO to my to-do list. But really, the class
is a pretty good one. It’s certainly been useful to me for, well, almost a few years now, give or take a few dozen tweaks.

So given the longevity of the script, I thought I’d offer it up for this week’s Script Sunday:

<br /> /**<br /> * Database constructor<br /> */<br /> class Database {</p> <p> protected<br /> $connection,<br /> $debug,<br /> $debug_func;</p> <p> /**<br /> * Constructor method. Connects to the database<br /> * @public<br /> */<br /> function __construct() {</p> <p> $this->debug = Array();<br /> $this->debug_func = ‘debugNone’;</p> <p> }</p> <p> /**<br /> * Gets the number of affected rows from the last query<br /> * @return integer Number of affected rows<br /> * @public<br /> */<br /> function affectedRows() {<br /> return mysql_affected_rows($this->connection);<br /> }</p> <p> /**<br /> * Checks a table to see if a key/value pair exists<br /> * @param string table The table to check<br /> * @param string field The field in the table<br /> * @param string value The value of the field to check<br /> * @return bool Returns true if it found a matching row<br /> * @public<br /> */<br /> function checkField($table, $field, $value, $and = ”) {</p> <p> $qry = sprintf(’<br /> SELECT<br /> %s<br /> FROM<br /> %s<br /> WHERE<br /> %s = “%s”<br /> %s<br /> ‘,<br /> $field,<br /> $table,<br /> $field,<br /> $value,<br /> $and<br /> );</p> <p> $res = $this->query($qry);<br /> $row = $this->fetchRow($res);</p> <p> return ($row ? true : false);</p> <p> }</p> <p> /**<br /> * Cleans a value for the DB<br /> * @param str $value The value to clean<br /> * @return str The cleaned string<br /> */<br /> function clean($value) {</p> <p> $value = stripslashes($value);<br /> $value = trim($value);<br /> $value = str_replace(”‘”, “\’”, $value);</p> <p> return $value;</p> <p> }</p> <p> /**<br /> * Connect to the database<br /> * @param string db_server The database server to connect to (often localhost)<br /> * @param string db_user The user to send to the server<br /> * @param string db_password The user’s password<br /> * @param string db_name The name of the database to use<br /> * @public<br /> */<br /> function connect($db_server, $db_user, $db_password, $db_name) {</p> <p> $this->connection = mysql_connect($db_server, $db_user, $db_password);<br /> $this->select($db_name, $this->connection);</p> <p> return ($this->connection ? true : false);</p> <p> }</p> <p> function debugNone() {}</p> <p> /**<br /> * Adds a debug message to $debug<br /> * @param str The debug message<br /> * @public<br /> */<br /> function debugPut($debug) {<br /> $this->debug[] = $debug;<br /> }</p> <p> /**<br /> * Deletes rows from the database<br /> * @param string table The table to query<br /> * @param string where There WHERE clause in the query<br /> * @param integer limit How many rows to limit (default is 1)<br /> * @return integer Number of affected rows<br /> * @public<br /> */<br /> function deleteRows($table, $where, $limit = 1) {</p> <p> $limit = ($limit ? ‘LIMIT ‘ . $limit : ”);</p> <p> $qry = ‘DELETE FROM ‘ . $table . ‘<br /> WHERE ‘ . $where . ‘<br /> ‘ . $limit;</p> <p> $this->query($qry);</p> <p> return $this->affectedRows();</p> <p> }</p> <p> /**<br /> * Retrieves a row from the database<br /> * @param string result The result set returned from the query<br /> * @return array Associatve index of the retrieved row<br /> */<br /> function fetchRow($res) {<br /> return @mysql_fetch_assoc($res);<br /> }</p> <p> /**<br /> * Get a single row from the database<br /> * @param qry The query to send<br /> * @return array Associative array of the row<br /> */<br /> function getRow($qry) {</p> <p> $res = $this->query($qry);<br /> $row = $this->fetchRow($res);</p> <p> return $row;</p> <p> }</p> <p> /**<br /> * Retreive rows from the database<br /> * @param qry The query to get the rows<br /> * @param array Numeric array of the rows<br /> */<br /> function getRows($qry) {</p> <p> $rows = Array();<br /> $res = $this->query($qry);</p> <p> while ($row = $this->fetchRow($res)) {<br /> $rows[] = $row;<br /> }</p> <p> return $rows;</p> <p> }</p> <p> /**<br /> * Format a query for insertion into the database<br /> * @param string table The table to insert into<br /> * @param array pairs Key value pairs of the fields and values to insert<br /> * @return string The prepared query, ready to insert<br /> */<br /> function formatInsert($table, $pairs) {</p> <p> foreach ($pairs as $field => $value) {</p> <p> $fields .= $field . ‘,’;</p> <p> if (!is_numeric($value)) {<br /> $value = $this->clean($value);<br /> }</p> <p> $values .= “‘$value’,”;</p> <p> }</p> <p> $fields = substr($fields, 0, -1);<br /> $values = substr($values, 0, -1);</p> <p> $qry = sprintf(”<br /> INSERT INTO<br /> $table<br /> ($fields)<br /> VALUES<br /> ($values)<br /> “);</p> <p> return $qry;</p> <p> }</p> <p> /**<br /> * Formats an update query based on a key/value array<br /> * @param string table The name of the table<br /> * @param array pairs The key/value pair of the fields/values<br /> * @param string where The WHERE clause of the array (default: 1)<br /> * @param integer limit The limit on tbe query<br /> * @return string The prepared query<br /> */<br /> function formatUpdate($table, $pairs, $where = ‘1′, $limit = false) {</p> <p> foreach ($pairs as $key => $value) {</p> <p> if (!is_numeric($value)) {<br /> $value = $this->clean($value);<br /> }</p> <p> $set .= “$key = ‘$value’, “;</p> <p> }</p> <p> $set = substr($set, 0, -2);<br /> $limit = ($limit ? ‘ LIMIT ‘ . $limit : ”);</p> <p> $qry = sprintf(”<br /> UPDATE<br /> $table<br /> SET<br /> $set<br /> WHERE<br /> $where<br /> $limit<br /> “);</p> <p> return $qry;</p> <p> }</p> <p> /**<br /> * Get the id of the last inserted row<br /> * @return integer They id (if it exists) of the last inserted row<br /> */<br /> function getID() {<br /> return mysql_insert_id($this->connection);<br /> }</p> <p> /**<br /> * Inserts rows into the database<br /> * @param string table The table to send the query to<br /> * @param array pairs The key/value pairs to insert into the database<br /> * @return integer Number of affected rows<br /> */<br /> function insertRows($table, $pairs) {<br /> return $this->query($this->formatInsert($table, $pairs));<br /> }</p> <p> /**<br /> * Gets the number of rows from a result set<br /> * @return integer Number of rows<br /> */<br /> function numRows($res) {<br /> return mysql_num_rows($res);<br /> }</p> <p> /**<br /> * Send a query to the database<br /> * @param string qry The query to send<br /> * @return string A reference to the result set<br /> */<br /> function query($qry) {</p> <p> $func = $this->debug_func;<br /> $this->$func($qry);</p> <p> return mysql_query($qry, $this->connection);</p> <p> }</p> <p> /**<br /> * Select a database on the server<br /> * @param string db_name The name of the database<br /> * @return bool Returns true on success and false on failure<br /> */<br /> function select($db_name, $connection = null) {</p> <p> if ($connection) {<br /> $this->connection = &$connection;<br /> }</p> <p> return mysql_select_db($db_name, $this->connection);</p> <p> }</p> <p> /**<br /> * Turns on or off the debug option<br /> * @param bool debug The new value of the debug option<br /> */<br /> function setDebug($debug) {<br /> if ($debug) {<br /> $this->debug_func = ‘debugPut’;<br /> } else {<br /> $this->debug_func = ‘debugNone’;<br /> }<br /> }</p> <p> /**<br /> * Updates rows in the database<br /> * @param string table The table to send the query to<br /> * @param array pairs The key/value pairs to insert into the database<br /> * @param string where The WHERE clause of the array (default: 1)<br /> * @param integer limit The limit on tbe query<br /> * @return integer Number of affected rows<br /> */<br /> function updateRows($table, $pairs, $where = ‘1′, $limit = false) {<br /> return $this->query($this->formatUpdate($table, $pairs, $where, $limit));<br /> }</p> <p>}<br />

And here’s a quick example of how to use it:

<br /> $db = new Database();<br /> $db->connect($server, $user, $password, $db_name);</p> <p>$query = ‘SELECT * FROM users’;<br /> $users = $db->getRows($query);</p> <p>foreach ($users as $user) {<br /> echo ‘Username: ‘ . $user['username'] . ‘<br>’;<br /> }<br />

• [Download database.php.txt] (6,848 bytes)
• [Download db-class.zip] (1,966 bytes)

./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)

If you’re in the bay area, check out The SF JavaScript Meetup #3, Monday, August 18th at 7:00PM. Last time, the infamous Douglas Crockford was there, so it’s sure to be a hoot! Here are the details:

As always, we will have plenty of awesome JavaScripters attending, a number of great talks on cutting-edge scripting concepts, and excellent networking potential. Come and hang out with the best scripters in the Bay Area, learn a lot, eat free food, and have fun.

The agenda

1. 7:00PM – Event starts and food (…and lots of it!) will be ready for eating
2. 7:20PM – A few words from our hosts, sponsors, and us
3. 7:30PM – An hour of high-quality talks and demos (5×12min)
4. 8:30PM – Networking, talking, learning, discussing, more questions for speakers, more eating, whatever…
5. 9:30PM – Start to wrap things up

The Address

I’ll be there, as will many of my fellow front-end engineer buddies.

Oh, and An Event Apart

Also (though I’m sure you’ve heard of this one), there’s An Event Apart: a two-day conference featuring Eric Meyer and Jeffrey Zeldman, maintained by the good folks who run A List Apart. This is another one I’m attending. Hope to see you there!

<br /> myObject = {<br /> child : {<br /> key : ‘value’<br /> },<br /> foo : ‘bar’<br /> };<br />

Sometimes I’ll even forget which language I’m in and I’ll try something like:

<br /> $myObject = object(’key’ => ‘value’);<br />

Which gives the result: Parse error: syntax error, unexpected T_DOUBLE_ARROW in test.php on line 1

What you can use in PHP, which are quite elegant and expressive, are associative arrays:

<br /> $myObject = array(<br /> ‘child’ => array(<br /> ‘key’ => ‘value’<br /> ),<br /> ‘foo’ => ‘bar’<br /> );<br />

But if you were depending on an object for one reason or another, you can use typecasting to make PHP’s syntax more like that of JavaScript:

<br /> $myObject = (object) array(<br /> ‘child’ => (object) array(<br /> ‘key’ => ‘value’<br /> ),<br /> ‘foo’ => ‘bar’<br /> );<br />

(Note that the (object) typecasting operator is needed at each level in the array.)
This will also help eliminate strict warnings. Because though you can (depending on your php.ini settings) use this syntax…

<br /> $myObject->child->key = ‘value’;<br />

… it may give you this warning: Strict standards: Creating default object from empty value in test.php on line 1

This PHP pattern to me is easily readable and makes the language more expressive, like our good friend JavaScript.

This is the first part of many articles I’m going to write about common interview questions in the vague and mysterious world of web development.
There are of course an almost infinite amount of questions one could be asked during an interview, but my questions are typically going to be
more about syntax and semantics than the probably more revealing questions on algorithms and problem-solving.

Without further ado, here are some common questions engineers get asked to see if they understand the basic syntax of PHP.

• What are the differences between single and double quotes?
• What are the differences between include() and require()?
• What does the === operator do?
• What does $$ signify?
• What are the various ways to append to an index array?
• How do you debug in PHP?
• Create a class and extend it.

Q: What are the differences between single and double quotes?

A:
The primary difference is that a string enclosed with double quotes is parsed. A string enclosed in single quotes is just a string literal.

<br /> var $foo = ‘bar’;</p> <p>echo ‘The value of foo is: $foo’; // The value of foo is: $foo<br /> echo “The value of foo is: $foo”; // The value of foo is: bar<br />

Q: What are the differences between include() and require()?

A:
The most prominent difference is that require() will throw an error if it fails to include the given file, and include() will not.

Q: What does the === operator do?

A:
Triple equals checks for both value and type:

<br /> $foo = ‘bar’;<br /> $pos = strpos($foo, ‘b’);</p> <p>if ($pos) {} // false: 0 is a falsy value<br /> if ($pos !== false) {} // true: 0 is not of the same type as false<br />

I like to ask if the engineer can think of an example (like the one above).
It’s almost guaranteed that a programmer that has been developing in PHP for an extended period needed === before.

Q: What does $$ signify?

A:
Double dollar sign signifies a variable variable:

<br /> $color = ‘red’;<br /> $red = ‘#ff0000′;</p> <p>echo $color; // red<br /> echo $$color; // #ff0000<br />

Q: What are the various ways to append to an index array?

A:
[see code]

<br /> $my_array = array(1, 2, 3);</p> <p>$my_array[] = 4;<br /> array_push($my_array, 5, 6);</p> <p>$my_array[count($my_array)] = 7; // This is possible but dumb<br />

I like this question because it’s easy on the surface, and engineers will almost always get the first two. When I say there’s one more way, an engineer’s
response is usually pretty revealing. Getting an answer like, “No there’s not,” shows (unearned) arrogance.
Candidates that figure it out on their own show thinking on their feet.

Q: How do you debug in PHP?

I think it’s probably most common for developers to use the quick-and-dirty echo statement. A better practice is to use error_log
or an external debugging library, because they won’t muck up the page and potentially cause other bugs.

Q: Create a class and extend it.

Not really a question, but still important.
I also ask about constructors and deconstructors, and make sure the candidate knows how to call the extended class’s constructor:

<br /> class Foo {<br /> function __construct() {}<br /> private function privateMethod() {}<br /> public function publicMethod() {}<br /> }</p> <p>class Bar extends Foo {<br /> function __construct() {<br /> parent::__construct();<br /> }<br /> }<br />

I also like to ask if public is required (it’s not because it’s the default state), and make sure that the engineer knows about protected
as well.
I like to have conversations about object-oriented programming rather than just asking syntax questions, because I’ve found it’s easier.

That’s it, really. These questions are just to see if an engineer is familiar with the surface of the language.
It could be argued that PHP is simple and quick to learn, and that these questions would shine a positive light on someone who spent a few hours reading about
PHP, and a negative light on experienced engineers who are fantastic but not very familiar with PHP.
It’s a valid argument, but again, this is just to test PHP knowledge.

If you know any questions similar to these, I’d love to hear about them in the comments.