|
PHP vs. CFML
PHP is a server platform
and a scripting language. The scripting language
contains many useful built-in functions that enable your
pages to display dynamic content. If you have developed
with the PHP scripting language, you'll find that the
ColdFusion language (ColdFusion Markup Language, or
CFML) is quite a bit different, but also similar in many
ways.
First of all, ColdFusion objects (tags) are all
inherently active. In ColdFusion, the tag takes care of
the creation and the cleanup. When the tag is placed on
a page, it is instantiated by the ColdFusion server. The
server takes care of the cleanup as well.
This differs from PHP. When developing in PHP, you
must create an instance of an object, use the object,
and then later destroy the object. For example, when
working with a recordset in PHP, you first create the
connection and the recordset:
<?php
$connMysqlbookstore = mysql_pconnect("tom", "tom", "mypassword") or
die(mysql_error());
mysql_select_db("bookstore", $connMysqlbookstore);
$query_rsGetOrders = "SELECT CustomerID, OrderDate FROM Orders";
$rsGetOrders = mysql_query($query_rsGetOrders, $connMysqlbookstore)
or die(mysql_error());
$row_rsGetOrders = mysql_fetch_assoc($rsGetOrders);
$totalRows_rsGetOrders = mysql_num_rows($rsGetOrders);
?>
Next, you must use the recordset on a page by
manually looping through your recordset:
<table>
<?php
do {
?>
<tr>
<td><?php echo $row_rsGetOrders['CustomerID']; ?></td>
<td><?php echo $row_rsGetOrders['OrderDate']; ?></td>
</tr>
<?php
} while ($row_rsGetOrders = mysql_fetch_assoc($rsGetOrders));
?>
</table>
And finally, if you are done with the recordset, you
must free the results and close the connection: <?php
mysql_free_result($rsGetOrders);
mysql_close($connMysqlbookstore);
?>
When doing the same thing in ColdFusion, remember
that the ColdFusion tags are the equivalent of a
server-side object in PHP. A <cfquery> tag is used
in place of the recordset in PHP:
<cfquery name= "rsGetOrders" datasource= "bookstore">
SELECT CustomerID, OrderDate FROM Orders
</cfquery>
This code creates the recordset. Once it's created,
all you have to do is display it. Looping is built into
the ColdFusion tags as well, so it's not necessary to
manually start or stop the loop. You can simply output
the results with a <cfoutput query> tag:
<table>
<cfoutput query="rsGetOrders">
<tr>
<td>#rsGetOrders.CustomerID#</td>
<td>#rsGetOrders.OrderDate#</td>
</tr>
</cfoutput>
</table>
The ColdFusion code has several advantages
that are evident right from the start: it's shorter and
more concise. It's also much easier to understand
exactly what the code does, even without programming
knowledge. Another advantage is that cleanup code isn't
required?you don't have to destroy your objects. The
server handles those details. Yet another advantage,
that may not be apparent from the code, is that you can
use this recordset again and again on the same page. You
avoid having to reset your pointers as you would in PHP
using a mysql_data_seek() or a similar construct.
Another thing you'll notice from the code is that the
database MySQL is specified. The PHP code will not work
with any other database. You can't simply upgrade your
database to MS SQL Server?because the code will not
work. You can use a database abstraction layer in PHP to
simplify the database communication, but that involves
learning another set of rules and more syntax. With
ColdFusion, all databases are handled the same way by
<cfquery>. The connection to the database is done
in the CF Administrator, and the ColdFusion programmer
doesn't have to deal with different syntax.
Using less code
Less code = less typing =
more time for programming the meat of your program. Now
you don't need to spend as much time on the mundane
aspects like the object creation, keeping track of your
loops, and the closing and releasing of objects.
ColdFusion simplifies these tasks across the board.
Take another example, which demonstrates a common web
programming task: sending an e-mail. The e-mail
functionality of PHP is built-in, as it is in
ColdFusion. However, the syntax is not as intuitive and
the code required is more verbose. Note that in both the
ColdFusion and PHP examples, we assume that the
administrator of the application server has set up the
mail server properly: <cfmail to="#form.tofield#"
from="admin@mywebsite.com"
subject="Your order has been placed">
<cfinclude template="message.cfm">
</cfmail>
If you've ever sent an e-mail from PHP, you know what
is required. First, the mail server must be set up
correctly on the PHP server. Next, you have to know a
little bit about what is required in your mail headers.
The PHP mail() function only takes four parameters?to,
subject, message, and header?but in many cases certain
headers have to be set or the mail will not go through.
Some servers will reject an email if the FROM field is
not included. For that reason, the headers have to be
manually concatenated with line feeds. Knowledge of mail
headers is necessary. Alternately, you can use a
pre-written script that you might find on the web. The
same simple e-mail sent from PHP might look like
this: <?php
$to = $_GET ["txt_tofield"];
// set the to field from an incoming form field
$subject = "Your order confirmation number is: ";
$subject .= $_SESSION_["order_number"];
$message = join("",file("message.txt"));
$from = "From: Admin <admin@mywebsite.com>";
$replyto = "reply-to: admin@mywebsite.com";
$header = $from; // set the from field in the header
$header .= "\n"; // add a line feed
$header .= $replyto; // add the reply-to header to the header
mail($to, $subject, $message, $header); // send the e-mail
?>
In the example above, notice that the body of the
message is included as a separate file (message.txt).
The message body could have easily have been hard-coded
into the program, but with ColdFusion, using include
files can be very beneficial. An include file in
ColdFusion is read and interpreted as though it were
part of the page, so it is a simple process to add a
text file to the body of an e-mail message. In PHP, you
have to read the file into an array and then join the
array. Newer versions of PHP will include better file
handling, however.
In ColdFusion, these include files can be
conditional. In other words, you can access different
include files based on criteria that you establish, such
as a value in a field from the database. For example,
inside the message.cfm page, you might have code that
looks like this: <cfswitch expression = #rsGetAllEmails.emailtext#>
<cfcase value="A05">
<cfinclude template="orders_5day.cfm">
</cfcase>
<cfcase value="A15">
<cfinclude template="orders_15day.cfm">
</cfcase>
<cfcase value="A30">
<cfinclude template="orders_30day.cfm">
</cfcase>
<cfcase value="A45">
<cfinclude template="orders_45day.cfm">
</cfcase>
</cfswitch>
This use of conditional includes can be extremely
useful in maintaining your pages. There is no
degradation in performance when using include files in
ColdFusion, so you can package your logic within
them.
Built-in functionality
One thing that will
become apparent after you've coded a couple of
ColdFusion sites?much of the same functionality that is
built into PHP, or offered as additional modules that
you can utilize, is also built right into the ColdFusion
language using the tag-based syntax. A few of the more
powerful ColdFusion tags (some of them new to ColdFusion
MX) are: | 
.gif){kind=tracking}
