Sending camelCase code to under_score code

Question

I'm working with JavaScript and PHP right now. My JavaScript uses camelCase while my PHP uses under_score for variable/object/array naming.

I often have JavaScript send data to PHP. In fact it's specially made to send to PHP.

So, my question is, should I write the data being sent to PHP by JavaScript in camelCase or under_score?

Also vice versa.

Heres an example

Javascript -> PHP

var fooBar = {firstName:"Daenerys",lastName:"Targaryen",titles:{...}};

PHP receives

var foo_bar = $_POST['fooBar'];

// this is where the problem arises
foo_bar['firstName'];
foo_bar['lastName'];

Edit: It's not a duplicate because I'm not asking whether the code should have the same code conventions, but which code convention takes precedence when communicating between each other.

Answer 1

The naming convention sent across the network is irrelevant. Just pick a convention and stick with it.

Each client can deal with the data directly, but in many cases building a layer of abstraction on top of those API calls is good practice. Mapping the API response to another object can rectify the naming convention differences.

JavaScript is the client, and PHP is on the server, therefore camelCase is perfectly fine. JavaScript will be consuming the data, and camelCase is the convention.

Things get murky when your server code services multiple clients in different tech stacks. So you start out with JavaScript. Then you add a Java Android application. Using camelCase still makes sense, because that's still the convention with Java.

But then you add a C# web application as a client of your PHP application. Now PascalCase is the convention. And throw in a Ruby web API for good measure, and we are back to snake_case again.

So it doesn't really matter what you pick, just be consistent.

Answer 2

There is no correct answer here. You will find as you use different tools from different vendors (or even from the same vendor, but with different heritages) that you will run into this problem. The best you can hope to do is be consistent in what you are writing.

If this is a major problem, you can always make named constants (which you should do regardless) that change it. For example in PHP, do this:

define("first_name", "firstName");
...
foo_bar[first_name]; // Or whatever the appropriate syntax would be

Answer 3

JSON is short for "JavaScript Object Notation" which clearly identifies it in the JavaScript domain, so JSON should use JavaScript camelCase. Even if your server is written in a language which uses Pascal case or underscores, it would be expected to work with JSON in its specific format, using its conventions.

Similarly, if your server is rendering CSS, you'd use lowercase with hyphens, consistent with CSS naming conventions. Same for any other platforms your server will come in contact with, e.g. your HTTP verb should always be in upper case.

Answer 4

You often have 1 server, 1 API and multiple clients written in different languages, but it's unlikely to have 1 client, 1 API and multiple servers written in different languages.

Therefore it's almost always more sensible for the server to define the API. Naming conventions of variable names on the API are part of the API.

---

Unfortunately that doesn't answer your question. Even though the server side defines the API, you may still decide that the API should use different naming conventions than the internal server representation - if you find that there's a tangible benefit in doing so. For example, you might prefer camelCase for a public API used by casual users which are more likely to get confused by multiple naming conventions in their codebase. Depending on the exact use case and support costs, you might even decide to support camelCase, under_score, and PascalCase, and automatically convert to the internal representation.

For simplicity, I recommend "leaking" the server side naming conventions, unless you can define a tangible benefit in not doing so for your specific use case.