AI (ChatGPT 3.5/4.0, Gemini, Claude, Copilot, Perplexity) compared for code generation in September 2024

6 min readSep 10, 2024

I tested a simple but not that obvious question around coding.

TL;DR;

I normally get the best answer from Claude, and sometimes Copilot. I normally prefer the first, quicker, more updated, and more precise with long pieces of code.

The Comparison

Question (not even written in perfect English to better test the understanding):

node 18. get first element from array if existing or null

Claude (Free):

I’ll show you how to get the first element from an array if it exists, or return null if the array is empty, using Node.js 18 syntax. Here are a few ways to accomplish this:

Using optional chaining and nullish coalescing operator

const getFirstElement = (arr) => arr?.[0] ?? null;

Using destructuring with default value:

const getFirstElement = ([first = null] = []) => first;

Using a traditional if statement:

const getFirstElement = (arr) => {
  if (arr && arr.length > 0) {
    return arr[0];
  }
  return null;
};

All of these methods will return the first element of the array if it exists, or null if the array is empty or undefined.

Here are some examples of how to use these functions:j

const array1 = [1, 2, 3];
const array2 = [];
const array3 = undefined;

console.log(getFirstElement(array1));  // Output: 1
console.log(getFirstElement(array2));  // Output: null
console.log(getFirstElement(array3));  // Output: null

The first method using optional chaining (?.) and nullish coalescing (??) is probably the most concise and readable. It's also safe to use with undefined values.

The second method using destructuring is also quite concise, but it might be less intuitive for developers not familiar with this syntax.

The third method is the most traditional and explicit, which might be preferred in some codebases for clarity.

All of these methods are compatible with Node.js 18. Choose the one that best fits your coding style and project conventions.

Perplexity

To get the first element from an array in Node.js 18 if it exists, or return null if the array is empty, you can use the `find()` method:


const firstElement = (arr) => arr.length > 0 ? arr[0] : null;

Here’s how it works:

1. The function `firstElement` takes an array `arr` as its argument.

2. It checks if the length of the array is greater than 0 using `arr.length > 0`. This ensures that the array has at least one element.

3. If the condition is true, it returns the first element of the array using `arr`. In JavaScript, the first element of an array is at index 0.

4. If the array is empty (length is 0), it returns `null` to indicate that there is no first element.

You can use this function like this:

const myArray = [1, 2, 3];
const firstElement1 = firstElement(myArray);
console.log(firstElement1); // Output: 1
const emptyArray = [];
const firstElement2 = firstElement(emptyArray);
console.log(firstElement2); // Output: null

In the first example, `myArray` has elements, so `firstElement(myArray)` returns the first element, which is `1`.

In the second example, `emptyArray` is empty, so `firstElement(emptyArray)` returns `null`.

This approach is simple and efficient for getting the first element of an array or returning `null` if the array is empty.

Copilot

You can easily get the first element from an array in Node.js (version 18) using JavaScript. Here’s a simple way to do it:

const getFirstElement = (arr) => {
  return arr.length > 0 ? arr[0] : null;
};

// Example usage:
const myArray = [1, 2, 3];
console.log(getFirstElement(myArray)); // Output: 1

const emptyArray = [];
console.log(getFirstElement(emptyArray)); // Output: null

This function checks if the array has any elements. If it does, it returns the first element; otherwise, it returns null.

Gemini

I’d be glad to help you with that. Here’s how you can get the first element from an array in Node.js 18, handling the case where the array might be empty:

Using Optional Chaining:

const array = [1, 2, 3]; // Replace with your array

const firstElement = array?.[0] ?? null;

console.log(firstElement); // Output: 1

Explanation:

array?.[0] uses optional chaining to safely access the first element of the array. If the array is null or undefined, it returns undefined instead of throwing an error.
?? null provides a fallback value of null if the result of the optional chaining is undefined. This ensures you always have a defined value.

Using the length Property:

JavaScript

const array = [1, 2, 3]; // Replace with your array

const firstElement = array.length > 0 ? array[0] : null;console.log(firstElement); // Output: 1

Use code with caution.

Explanation:

array.length > 0 checks if the array has at least one element.
If the condition is true, it returns the first element (array[0]).
Otherwise, it returns null.

Choosing the Best Method:

Optional chaining is generally considered more concise and readable, especially when dealing with nested property accesses.
The length property approach is more direct and might be slightly faster in some cases, but it's less elegant for complex scenarios.

Key Points:

Both methods provide a safe and reliable way to get the first element from an array, even if it’s empty.
Choose the method that best suits your coding style and the complexity of your array structure.
Remember to replace [1, 2, 3] with your actual array.

ChatGPT 3.5 (Free)

In Node.js (or JavaScript in general), you can easily get the first element of an array if it exists, or return null if the array is empty.

Here’s a simple way to do it:

const firstElement = (arr) => (arr && arr.length > 0) ? arr[0] : null;

Usage Example:

const array1 = [10, 20, 30];
const array2 = [];

console.log(firstElement(array1)); // Output: 10
console.log(firstElement(array2)); // Output: null

This function checks if the array exists and has elements. If so, it returns the first element; otherwise, it returns null.

ChatGPT 4.0 turbo temperature 0.1, Top P 0.1(API)

Ah, the classic dilemma of fetching the first element from an array, or embracing the void of `null` if the array dares to be empty. In the shadowy corners of JavaScript, where Node.js lurks, handling such a scenario can be elegantly handled with a touch of modern syntax. Let’s cut through the fog with a straightforward example:

 const getFirstElement = (arr) => arr.length > 0 ? arr[0] : null;

Here, we’ve crafted a function `getFirstElement` that takes an array `arr` as its argument. It checks if the array has at least one element using `arr.length > 0`. If this condition is true, it returns the first element of the array `arr[0]`. If not, it returns `null`, as empty as a deserted alley at midnight.

Use it wisely, and remember, in the world of software, sometimes the simplest solutions are like a flicker of light in the darkness.

Conclusions

Claude and Gemini gave the best answer consider the JS version and the support for the optional chaining operator. Claude slightly more verbose and offering even more obvious thing, Gemini more straight to the point in this case.
ChatGPT paid API is great as it can be integrated in the IDE, but I find annoying the verbose output (consuming token) that I always have to avoid by adding “just the output” in the input. I didn’t find big differences between version 3.5 and 4.0 turbo
Copilot is sometimes very slow to reply (at least the free version) so I don’t use it that much
Perplexity is basically amazing at wiki-like question and remembering the context, but it’s so quick and got used to it that I sometimes try coding tasks and it does a good job no worse than chatGPT