PHP vs. Node.js

TL;DR: PHP is not going to disappear immediately, but its positions are undermined even further by the nascent Node.js.

When the Internet exploded in the 2000s, PHP was a thing all the cool kids did. It was extremely revolutionary, because:

  • It was an interpreted language unlike C++ or Java which require the source code compilation
  • It had the ability to be used directly with HTML by mixing within its template files with a <%php ... %> markup tags
  • It had cheap shared hosting providers on Apache servers with a Linux, Apache, MySQL and PHP (LAMP) stack
  • It had a functional nature which is easier to learn than the object-oriented programming

Over the years, PHP and its apps became a monstrous technology vulnerable to security threats (e.g., SQL injections), lack of a centralized packaging registry (was Composer inspired by Node Package Manager?), inconsistent API and subpar performance. There are many better alternatives to PHP, e.g., Ruby on Rails and Django, however nothing is as approachable as Node.js.

For those of you who aren’t familiar with Node.js, or who have heard of it but can’t quite grasp the concept, here is my analogy:

Node.js is functionally similar to the PHP + Apache or ASP + IIS stacks.

Nowadays, Node.js is gaining momentum. The platform uses JavaScript. It’s functional, and its non-blocking I/O mechanism allows for a better performance. Node.js comes with a robust Node Package Manager solution and the specification, i.e., ECMAScript.

Because Node.js is a lower-level technology, it is not comparable to complex frameworks like Struts, Rails or Django directly.

Therefore, many people, whether software engineers or entrepreneurs, are often faced with the decision of “What tech stack to use” In this article PHP vs. Node.js, we’ll compare apples-to-apples approaching the question from different angles, such as:

  • Syntax
  • Context switch
  • Modules
  • Ecosystem
  • Frameworks
  • Real-time apps
  • Database apps
  • Third-party services apps
  • Web servers
  • Hosting
  • Performance

Syntax

Both platforms have access to the command line interface via $ php -i and $ node.

This snippet prints ‘Hello World’ in PHP:

echo 'Hello World'; 

This will output the same phrase in Node.js:

console.log('Hello World');

Note: In JavaScript semi-colons are optional except when inside of the for loops and before immediately-invoked function expressions (IIFE).

Sleep function script example in PHP:

echo "a"."\n";
sleep(2);
echo "b"."\n";
echo "c"."\n";

The above code will output:

a

And then after a 2 second delay:

b
c

If we try to re-write the code in Node.js:

console.log('a')
setTimeout(function() {
  console.log('b')
 },2000)
console.log('c')

This snippet will print:

a
c

And with a 2 second delay, it will print:

b

Note: In JavaScript, console.log() automatically adds the end of line symbol.

The for loop in PHP might look like this:

for ($i = 1; $i <= 10; $i++) { 
  echo $i;
} 

They’re strikingly similar in Node.js:

for (var i = 0; i <= 10; i++) { 
  console.log(i);
} 

To create an array in PHP:

$users = array( 
  array('name' => 'John', 'id' => 3940), 
  array('name' => 'Peter', 'id' => 8904) 
); 

To create an array in Node.js:

var users = [ 
  { name: 'John', id: 3940 }, 
  { name: 'Peter', id: 8904 } 
] 

To iterate through an array in PHP:

for($i = 0; $i < count($users); ++$i) { 
  $users[$i]['id'] = mt_rand(000000, 999999); 
} 

To iterate through an array in Node.js:

for (var i; i < arr.length; i++) {
    users[i] = Math.floor(Math.random()*1000000);
} 

Or in a functional manner:

users.forEach(function(user, i){ 
  users[i] = Math.floor(Math.random()*1000000); 
}) 

To declare a function in PHP:

function hello($name) {
  echo "Hi ".$name;
}
hello("Peter"); //outputs Hi Peter

To declare a function in Node.js:

function hello(name) {
  console.log('Hi' + name);
}
hello('Peter'); //outputs Hi Peter

To declare a new object in PHP:

class foo {
    function do_foo()  {
        echo "Doing foo."; 
    }
}

$bar = new foo;
$bar->do_foo();

To declare a new object in Node.js:

var foo = function () {
  return { 
    do_foo: function () {console.log('Doing foo');}
  };
};

var bar = foo();
bar.do_foo();

Note: there are no classes in Node.js/JavaScript, because objects inherit directly from other objects (prototypal inheritance). There are many instantiating patterns such as pseudo-classical, functional(above) and classical.

A database snippet with the PDO database connection library in PHP:

$pdo = new PDO('sqlite:users.db');
$stmt = $pdo->prepare('SELECT name FROM users WHERE id = :id');
$stmt->bindParam(':id', $_GET['id'], PDO::PARAM_INT); //<-- Automatically sanitized by PDO
$stmt->execute();

A Node.js database script with the Mongoskin MongoDB library:

//assuming we use Connect/Express middleware for req.query
var db = require('mongoskin').db('localhost:27017/db'); 
db.collection('users').find({_id: req.query.id}).toArray(function(err, results) {
    if (err) throw err;
    console.log(results);
});

Context Switch

The Switch between different environments and languages is attributed to the drop of efficiency when writing software code. Many researches and personal anecdotal observations show that interruption negatively impacts programmers’ performance. With less languages to learn and remember the flow is smoother and the code is better! For a deeper articles on this subject you might want to take a look at Human Task Switches Considered Harmful and The Multi-Tasking Myth.

PHP

With the LAMP stack, i.e, Linux, Apache, MySQL and PHP, developers must master at least two more languages which are PHP and SQL in addition to the mandatory and omnipresent HTML, CSS and JavaScript.

Node.js

Node.js is brilliant at having less context switches, because together with MongoDB, this stack can operate only in one language: JavaScript!

An example of MongoDB shell commands (called by $ mongo):

> db.users.find({});
> db.users.insert({name: 'Azat', email: 'azat@rpjs.co'})
> db.users.update({name:'Azat'},{$set:{email:'hi@rpjs.co'}})

Modules

PHP

There is PEAR, a veteran system which installs packages on a server globally, and a better alternative Composer.

In other cases, developers had to seek modules — or components as they call them — on various websites, and to administer them manually by placing *.php files into sub-folders of their projects. Unfortunately, all this is not very kosher.

Node.js

Node.js comes with a superior and dependable package management system called NPM and its registry npmjs.org which is easy to use and publish. Everything is administered via the package.json file and versioned locally, unless we’re installing a CLI tool with the -g option.

Both PHP and Node.js are functional languages with a relatively later addition of OOP to PHP.

Ecosystem

PHP

This is probably one of the most important areas where PHP still beats Node.js. There are amazing open-source applications, e.g., WordPress, tons of free scripts, quality tools and books.

Node.js

Node.js is growing faster than any other platform/language. This is mostly due to the philosophy of keeping modules minimal and performing only a small set of tasks. Other factors might include such things as:

  • The gigantic popularity of front-end JavaScript among web developers
  • Existence of the specs, and abundance of JavaScript resources and gurus (such as Doug Crockford) amassed during the language’s many years of existence
  • Collaborative GitHub open-source community based on an awesome distributed version control system that didn’t exist before
  • Ease of NPM use, e.g., to publish an NPM module run $ npm publish

As a result, some people predict that Node.js will surpass other languages in the absolute number of contributions.

Frameworks

It’s important to have rich tools and proven libraries at our disposal.

PHP

CakePHP and Zend come to mind, and for more choices there is an extensive list.

Node.js

Playing field is relatively leveled with Express.js being the most popular choice, and the full-stack MVC frameworks Meteor and Derby showing the way to the future.

Real-time apps

PHP

For PHP, there is still Node.js dependent Elephant.io and some other approaches. The problem with native PHP and websockets is that Apache and ISS — where PHP is usually run as a module — weren’t really built with persistent connection in mind. Therefore, developers have to use the standalone processes like: Apache WebSocket or Ratchet.

Node.js

Real-time apps building is just a breeze with Node.js stack of the Socket.IO library, Express.js framework and Handlebars reactive template engine. In the Meteor and Derby projects, real-time apps building is taken one step further by combining front and back-end code bases with the persistence layer which reduces the complexity and speeds up the development dramatically.

Database apps

PHP

PHP has a long and fruitful history with traditional/relational databases like MySQL, hence the name of the stack LAMP — Linux, Apache, MySQL and PHP.

Node.js

Node.js is natural with NoSQL databases like MongoDB.

The databases’ performances are somewhat comparable to each other depending on the use cases as per MySql vs MongoDB performance benchmark(MySQL), Simple Test : MongoDB vs MySQL(MongoDB) and MongoDb vs MySql – Fight!!!(MongoDB) articles. However, MongoDB is superior for distributed databases and is highly scalable. The added bonus is that without a fixed schema, NoSQL databases are perfect for cloud computing, prototyping and agile projects.

Third-party services apps

PHP

As is the case with many traditional languages, PHP’s flow is blocked ’til the remote server has responded, hence the need for multi-threading.

Note: Some languages provide this feature when special libraries/frameworks such as EventMachine for Ruby or Twisted for Python are used. However, they’re very complex and weren’t built from the ground up with the platform.

Node.js

On the contrary, due to a non-blocking I/O, Node.js can handle multiple requests and make multiple requests as a client to a third-party services (e.g., Twitter, Amazon) with just one thread of execution.

Web Servers

PHP

Since PHP 5.4 and higher, there is a build-in development server that we can started with:

$ php -S localhost:8000

Assuming we have index.php in that folder:

<?php
  echo 'Hello World';
?>

For versions prior to 5.4, there are ‘all-in-one’ tools like MAMP and XAMPP.

As for the production environment, PHP can’t be run on its own. One of the most popular technologies used with PHP are Apache and nginx where PHP is just a module of Apache web server. My personal experience of Apache is that it has a steep learning curve and while being very configurable, by default those configurations are prone to security leaks.

Node.js

Node.js was created from the ground up for the network applications and there is a set of core modules to write web servers.

To start a Node.js server:

$ node .

Assuming our index.js file in this folder has:

var http = require('http');
http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end('Hello World\n');
}).listen(1337, '127.0.0.1');
console.log('Server running at http://127.0.0.1:1337/');

In production, Node.js can be run on SmartOS or Linux (like Ubuntu) as a service.

Note: Multi-threading is absolutely possible in Node.js with clusters and/or external modules.

Hosting

PHP

PHP owes its popularity mainly to the ease and cheapness of offered shared hosting solutions. True, it’s hard to find one without the LAMP stack on it. This commoditization sometimes leads to security holes and less than acceptable downtime due to hosting providers overselling and other consumers using malicious code.

Platform as a Service is a better alternative and somewhere in between full fledged dedicated server and shared hosting. Most of PaaS providers support PHP right of the bat.

Node.js

Node.js works nicely on PaaSs, with Heroku and Nodjitsu leading the list. Also, the cloud infrastructure company Joyent (the maintainer of Node.js), developed powerful operation system SmartOS that allows for performance bursts, painless deployment and DTrace debugging.

Performance

It’s needless to say that performance is important. This resource shows different benchmark tests: Which programs are fastest?.

PHP

PHP is relatively fast but due to its bottleneck in the file system, database and third-party requests, it fails miserably in comparison with Node.js and its super fast Goolge Chrome V8 engine.

For example, when Facebook reached its scalability limits with PHP, they wrote an extremely fast C++ library and virtual machine which they called HipHop VM, but kept the PHP API.

Node.js

Node.js is extremely fast due to its non-blocking I/O mechanism and Google Chrome V8 engine technology. I even heard that Joyent started re-writing some of their C++ modules in Node.js.

Conclusion

PHP was an outstanding technology in its days. Its success and popularity came from:

  • Its ease of learning and use
  • cheap and straightforward hosting mostly shared LAMP
  • Abundance of open-source scripts, apps and libraries

At the same time, these same things now led to its dusk. The contributions to the core from beginner programmers metamorphosed API inconsistently while the lack of OOP/classes and module management systems inhibited open-source community growth. Absence of a leading framework (Ruby on Rails comes to mind as an example of a single dominance) or a paradigm that also helped to produce a lot of bad code that relied heavily on mixing PHP and HTML code without any MVC-ishness. On the other hand, there are a lot of good products and infrastructure for PHP that are here to stay.

Node.js is relatively young with only three years since its first commit, but it’s already the fastest growing platform by the pace of contributions (the absolute number will surpass other languages in a few years). The fact that JavaScript language is the most popular language in the world and has the biggest run-time internment of course attributed to that. Many tools are ported to Node.js with small or no modification from the browser environment. Also, great books on JavaScript fundamentals (for example, JavaScript: The Good Parts and Eloquent JavaScript) experienced surge in the popularity again.

Node.js is very efficient and great for building real time, NoSQL oriented and scalable systems.

Disclaimer

I worked with many technologies including Ruby on Rails, Python, Java/J2EE, VB, ASP, Perl and of course PHP. One of my most complex PHP projects was openList.co which involved use of the MVC pattern with template engines, classes, database abstraction layer and .htaccess re-routing. However, my focus during the past couple of years has been dedicated solely to Node.js and front-end JavaScript frameworks like Backbone.js. So my opinion might be biased, please comment on your experience with real projects in both PHP and Node.js.

If you want to learn more about Node.js take a look at my artisanal book Rapid Prototyping with JS: Agile JavaScript Development and the astonishing coding intensive full-time course at HackReactor.

32 thoughts on “PHP vs. Node.js

  1. Matt kukowski

    node.js v PHP is like comparing apples to oranges.

    node.js is a COMPLETELY different LANGUAGE for one. And second, a COMPLETELY different coding style.

    PHP is C like (with classes, procedural style)
    JavaScript is Event Driven built in, has a Completely different notion when it comes to creating Classes and inheritance and OOP in general.

    I think what scared PHP programmers the most about node.js is that it is a REAL and TRUE possible replacement not for just PHP… but for rapid applications development, period.

    JavaScript progammers of the browser will not need to learn another language… this in the corporate business world is a MAJOR plus, because that is just the way they think.

    I think that PHP’s days are numbered. Not because I want it to be… oh no.. I have 10+ years invested with PHP. And now all these ‘new jobs’ are calling for node.js and angular and all this javascript! Which means having to RELEARN and throw away PHP.

    I think node.js scares PHP programmers because it has some SERIOUSLY good things going for it, as I mentioned above.

    But, there is a LOT of PHP code out there… and javaScript is a wonderful language. But, there is going to be a learning curve in terms of the prototype for class creation and the Event Driven Model… I think that if you want to keep up with the world of web programming… ALL PHP programmers had better take node.js and javascript invasion ( and it is an invasion ) seriously.

    PHP programmers better at least look into creating express apps, socket.io and learn some JavaScript.. after all it will make you good on the Front end in the Browser too.

    This is what I fear. I fear that Corporate is going to want it ALL from the node.js invasion.. they are going to want that one Guru PHP programmer to ALSO be a kick ass jQuery/Angular Front end programmer… and that means design and styling and all that.

    IMHO that is a lot to ask for, in one person. Just because javaScript is the same language that runs the browser logic, can now run the server logic, does not make you adept and therefore REQUIRED to do BOTH.

    What do you guys think? node.js is growing, and is going to really kick PHP’s ass, in due time… but like I said there is plenty of PHP code out there, so use this time you PHP programmers to get to know node.js and JavaScript server side while you have spare time..

    The node.js flood is upon all PHP programmers, whether you like it or not. Dont, mean PHP will die anytime soon. Nginx (is event driven) and with php-fpm still gives node.js a run for its CPU cycles.

  2. José Moreira

    To declare a new object in Node.js:

    var bar = {}; // or new Object();

    To declare a instance of a class: (that’s what php do with the class syntax)

    var foo = function () {
    return this;
    };
    foo.do_foo: function () {console.log('Doing foo');}

    var bar = new foo();
    bar.do_foo();

  3. José Moreira

    To declare a new object in Node.js:
    “`
    var bar = {}; // or new Object();
    “`

    To declare a instance of a class: (that’s what php do with the class syntax)
    “`
    var foo = function () {
    return this;
    };
    foo.do_foo: function () {console.log(‘Doing foo’);}

    var bar = new foo();
    bar.do_foo();
    “`

  4. Pingback: Node.js vs Laravel - Joseph D. Purcell

  5. damir

    Hi

    thanks for article, and especially thanks for comments!

    I need to start a new project and I am not sure if start with PHP or nodejs.

    The main problem is learning curve, since I am PHP developer, and just start learn nodejs world.

    I love the real time feature of nodejs, and I would like to know by someone here what think about PHP solution for “Event-driven, non-blocking I/O with PHP” http://reactphp.org/

    @Luciano Mammino I like your comment, but you said:
    “At the moment the greatest hole that remains uncovered (that privileges Node.js) is about real time applications development.”

    reactphp can be a solution for this?

    I would like continue my work on PHP, but it’s not first time that I hear about not secure future of LAMP stack, and speak about nodejs as future.

    Why facebook and many other main site are not in nodejs but in PHP? Because nodejs exist just 3 years.

    If nodejs exist since PHP start, which will be the most used technologies now day?

    I think the most accurate comments (and most near the true) is by @Luciano which resume it last phrase:

    “Definitely I feel that Node will keep stealing part of PHP market in the next years but I am pretty sure the two languages will coexist without great hurdles.”

    Thanks!!

  6. Shahmi

    Hello!
    I came here via Google (this page has a good SEO though) after I recently suggested by my fellow friend about node.js.
    I heard it quite a long time ago but I didn’t sure what is it. But today, after reaching your website, I found your comparison between PHP and Node.js is horribly unfair.
    Even that in your post you are praising Node.js so much, but to me, it seems like php is somewhat better. I am not challenging you for any of debates or some sort, but this is just in my opinion.
    I am not a great programmer yet, I sure know that. However, since Node.js seems to be hard to be learnt, and based on other people’s comments, I think I would rather stay using PHP due to its bright future.
    No offense to the Node.js. I believe any programming languages should live as long as it suits every programmer :)

    thanks for the post.

  7. Raye

    First of all, I was a PHP programmer. I do .net programs recently. All I concern is not the difference of syntax, but the scalerbility. In large projects we are not much aware of the lines of code. The most important thing is to modulize works and assign to team members.

    I came here is due to the event driven feature of Node.js. which I think Node.js is worth to take a look into. Event driven is hard to handle for squence style programmers. But it reacts more similar to real world.

    Besides, Is there any print services suitable for Node.js? please let me know if any

  8. Pingback: 讀書會 – Node.js開發指南(簡)/Google御用網頁語言Node.js:一流程式設計師養成精華(繁) | 狒吠

  9. Machete

    I have to disagree. NodeJS is perfect for high throughput problem-solving, but it is unsuitable for larger projects, simply because js is an prototype based language.
    That being said, NodeJS _is_ faster in many ways, but one of the largest sites in the world (aka facebook) run a major part of their code in PHP. From your complex project I can see, that there is no OOP whatsoever and no framework has been used whatever so I highly have to doubt your high aspirated critizism.

    And just on a side note, all-in-one solutions are never as good as a mixture of technologies, simply because the specialization is missing.

  10. Pingback: node.js intro

  11. Dimitri

    Interresting analysis, but as you said, i think you are completly biased and there are few things more to take in considaration;)
    One thing to take into consideration when choosing your langage is the pool of CAPABLE developpers (in opposition to “wanna be” ones) and there without any surprise PHP is still far ahead.
    Another point coming strait from the previous one is the cost of the technology, not by itself, but all together, and there once again, PHP wins (more devs, mean, less expensive at same experience/quality level). Same for system administrator (if needed) loads of them are really experemented on LAMP systems
    You also have to think about evolutivity and maintainance (i know PHP is pretty good on that with lots of security patches for older versions but i don’t know for node)

    i’ll finish by a sentence i heard (i don’t remember who, or the exacte phrasing but it was something like) :
    Javascript is like a pornstar, you can lots of things with it, but at some point, it’s gonna get dirty

    PS: Good lord, would you mind using foreach loop (as said a previous comment), they are so much more efficient to loop on an iterable variable that they should remove for from the language…;)

  12. Azat Post author

    Hi Paulo,

    That’s right, Django and Ruby on Rails are frameworks. However, there is no mistake here, because they are all alternatives to each other (some better, some not).

  13. Paulo Freitas

    “There are many better alternatives to PHP, e.g., Ruby on Rails and Django”

    You mean Python. Django is a framework.

  14. Pingback: Mon retour sur le passage de PHP à Node.js « Throrïn's Studio

  15. Azat Post author

    Sure, there are multiple ways to iterate over an array. The snippets above are just for illustration due to the fact that the comprehensive language comparison is the topic for another vast article in itself.

    It tends to be that web development is moving toward generalism. In addition to that 99% of startups for whom the question “PHP vs. Node.js” is important have only one or two developers.

    It’s pointless to write comparison articles for big companies, because let’s be honest, most of the time you work with what you have to work. :-)

  16. potherca

    A couple of points of critique :

    As of 5.4 you can also use the short array syntax in PHP, which replaces array() with [].

    Why aren’t you just using foreach in your PHP array itteration? Your code will be a lot less cluttered.

    Depending on how large the company is you work for, you may not even have to switch between front and backend context because they belong to separate developers or teams even. So yeah.

    The same goes for having to learn two extra languages… Odds are that if your company is more than a few developers big there an mysql expert or DBA, or that your DB is abstracted away by Doctrine or another framework savong you the hassle of having to write queries yourself. Apache ditto.

    Having said that, being able to use (parts of) the same code in both the browser and the server is a big advantage of node.js, although I personally prefer CouchDb for this.

    Maybe CouchDb versus Node.js could be next? :-)

  17. Rodrigo

    Nice post. But, I think the huge propagation of Node.js is very dependent of the NoSQL paradigm.
    Because most applications in someway needs a very reliable databases, and NoSQL isn’t widely used.
    As a PHP programmer, I must to recognize the fascinating and simple characteristics of Node, and I really hope that it grows quickly.

    Thanks for sharing knowledge!

  18. Pingback: Node.js vs. PHP | Flippin' Awesome

  19. Mick

    “There are many better alternatives to PHP, e.g., Ruby on Rails and Django”

    Why do you compare programming languages to frameworks? You should rather comapre Symfony2 to Django.

  20. Luciano Mammino

    Hi Azat,
    I really enjoyed your post and your comparison of PHP and Node.js.
    I’m a PHP developer with several years of experience. I also had time to work with Java, VB.net, Javascript, Python and Ruby, but my language of choice remains PHP.
    I do agree with many points in your analisys, but I don’t think PHP is such an obsolete language and even more that it’s going to disappear. I don’t want to criticize your point of view because I’m not so experienced with Node.js and probably I can see only one side of the comparison.
    I admit PHP was such a mess few years ago, especially if compared with language such as Java and Ruby (and their great tools and frameworks). Anyway the PHP community has several great developers and they probably felt something has to be done to make PHP a better language, up to date with current needs.
    So many good projects came to life: PHPSpec, PHPCS, phpmd, pdepend, Behat, Mink, Boris, Composer, Symfony2 components, Doctrine2, Twig and so on (I know, I mixed totally different tools and libraries, but I just wanted to point out the amount of good projects that has been produced by the PHP community in the last 2/3 years). Furthermore frameworks like Symfony2 and Zend Framework2 (and their whole community) heavily encourages OOP and its best practices. With PHP 5.3 and PHP 5.4 the language also improved its OOP features with namespaces and traits.
    That’s just to say that PHP has still a solid base and it’s improving everyday. It has many defects but also a great community providing great tools to fix them.
    At the moment the greatest hole that remains uncovered (that privileges Node.js) is about real time applications development.
    Definitely I feel that Node will keep stealing part of PHP market in the next years but I am pretty sure the two languages will coexist without great hurdles.

Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>