Claude vs. ChatGPT vs. Gemini: Who Nails These JavaScript Tips?

The world of AI chatbots is exploding, with powerful models like Claude, ChatGPT, and Gemini making waves. But when it comes to technical expertise, can these impressive language models really deliver? I put them to the test, asking for advanced JavaScript tips that might even surprise a seasoned developer. Let’s see who rose to the challenge…

Can you generate 5 javascript tips even a senior software engineer doesn’t know with code examples?

Gemini 1.0 Pro

Here are 5 JavaScript tips that even senior engineers might find useful, along with code examples:

  1. Destructuring assignment for nested objects: While destructuring assignment is common, it can be used for nested objects in a concise way. This can improve readability in complex data structures.


const data = { user: { name: "Alice", location: "Wonderland" } };

// Traditional approach
const userName =;
const userLocation = data.user.location;

// Using destructuring
const { user: { name, location } } = data;

console.log(name, location); // Output: Alice Wonderland
  1. Optional Chaining for safer navigation: Optional chaining (?.) allows you to safely access properties of potentially undefined or null objects without errors. This prevents runtime exceptions and improves code robustness.


const user = { profile: { name: "Bob" } };
const nonExistentUser = null;

// Traditional approach (might cause errors)
const nonExistentUserName =;  // Throws error

// Using optional chaining (safe access)
const safeUserName = nonExistentUser?.profile?.name;  // safeUserName is null

console.log(user?.profile?.name); // Output: Bob
console.log(safeUserName);        // Output: null
  1. Regular Expressions with Lookarounds: Lookarounds in regular expressions allow you to match or exclude patterns based on their surrounding characters. This can be useful for more precise pattern matching.


const text = "ABCA  BC";

// Match only the first occurrence of "BC" not followed by another "BC"
const regex = /(?<!B)BC/;

const matches = text.match(regex);
console.log(matches); // Output: ["BC"]
  1. Symbol as property keys: Symbols are unique and immutable values. Using symbols as property keys can prevent accidental property name collisions, especially useful for private properties or meta-data.


const user = {};
const userIdSymbol = Symbol("user-id");

user[userIdSymbol] = 123;

// Accessing the property using the symbol
console.log(user[userIdSymbol]); // Output: 123

// Won't work with dot notation (avoids accidental access)
console.log(user.userIdSymbol); // Output: undefined
  1. The Spread Operator with Objects: The spread operator (...) can be used to merge objects while creating a new one. This allows for easy object cloning with modifications.


const person = { name: "Charlie" };
const details = { age: 30, city: "New York" };

// Merge person and details into a new object (cloning)
const combined = { ...person, ...details };

console.log(combined); // Output: {name: "Charlie", age: 30, city: "New York"}

// Modify the cloned object without affecting the original
combined.occupation = "Developer";
console.log(person);   // Output: {name: "Charlie"}

These are just a few examples, and the most useful tip might depend on the specific project or coding style. However, these techniques can help write cleaner, more robust, and expressive JavaScript code.

ChatGPT 3.5

Sure, here are five JavaScript tips that even a senior software engineer might find useful, each accompanied by a code example:

  1. Using Object.freeze() with Deep Objects:
    It’s well-known that Object.freeze() can be used to prevent modifications to an object. However, when dealing with nested objects, you need to recursively freeze them to ensure immutability.
   function deepFreeze(obj) {
       Object.keys(obj).forEach(key => {
           if (typeof obj[key] === 'object' && !Object.isFrozen(obj[key])) {
       return Object.freeze(obj);

   const obj = {
       a: 1,
       b: {
           c: 2


   // Now, obj and its nested objects are immutable
   obj.b.c = 5; // Throws an error in strict mode
  1. Memoization with WeakMap for Memory Efficiency:
    Memoization is a technique used to cache the results of expensive function calls. Instead of using a regular object for caching, you can use WeakMap to avoid memory leaks.
   function memoize(fn) {
       const cache = new WeakMap();
       return function(...args) {
           if (cache.has(args)) {
               return cache.get(args);
           const result = fn(...args);
           cache.set(args, result);
           return result;

   // Usage
   const memoizedFunc = memoize(expensiveFunction);
  1. Detecting JavaScript Memory Leaks with Chrome DevTools:
    You can use Chrome DevTools to detect memory leaks in your JavaScript code by taking heap snapshots.
   // Trigger a memory leak
   function createMemoryLeak() {
       const arr = [];
       for (let i = 0; i < 10000; i++) {
           arr.push(new Array(10000).join(''));


   // In Chrome DevTools, go to the "Memory" tab, take a heap snapshot, and compare snapshots to find leaks.
  1. Replacing switch Statements with Object Lookup for Performance:
    In some cases, replacing switch statements with object lookup can improve performance, especially when dealing with a large number of cases.
   const actions = {
       'case1': () => { /* do something */ },
       'case2': () => { /* do something else */ },
       // Add more cases as needed

   // Instead of switch
   function performAction(action) {
       if (actions[action]) {
       } else {
           // Handle default case
  1. Using ES6 Proxies for Transparent Caching:
    ES6 Proxies can be used to create transparent caching layers for objects, allowing you to intercept and customize operations.
   const cache = new Map();
   const expensiveCalculation = new Proxy({}, {
       get(target, property) {
           if (!cache.has(property)) {
               cache.set(property, /* perform expensive calculation */);
           return cache.get(property);

   // Usage
   console.log(expensiveCalculation.result); // Calculates and caches result
   console.log(expensiveCalculation.result); // Retrieves result from cache

Claude 3 Sonnet

Sure, here are 5 JavaScript tips that even experienced developers might not know, along with code examples:

  1. Optional Chaining Operator (?.):
    This operator was introduced in ES2020 and allows you to read the value of a nested object property without having to check for nulls or undefined at every level. It returns undefined instead of throwing an error if any reference in the chain is null or undefined.
const user = {
  name: 'John Doe',
  address: {
    city: 'New York',
    country: {
      name: 'USA'

console.log(; // 'USA'
console.log(user.job?.title); // undefined (without an error)
  1. Nullish Coalescing Operator (??):
    Introduced in ES2020, this operator returns the first operand if it’s not null or undefined. Otherwise, it returns the second operand.
const value = null ?? 'default'; // 'default'
const name = 'John' ?? 'Guest'; // 'John'
  1. Array.flat() and Array.flatMap():
    flat() creates a new array by flattening the sub-array elements of the original array. flatMap() first maps each element using a mapping function, then flattens the result into a new array.
const arr = [1, 2, [3, 4, [5]]];
console.log(arr.flat()); // [1, 2, 3, 4, [5]]
console.log(arr.flat(2)); // [1, 2, 3, 4, 5]

const data = [1, 2, 3, 4];
const result = data.flatMap(x => [x, x * 2]);
console.log(result); // [1, 2, 2, 4, 3, 6, 4, 8]
    This method introduced in ES2022 allows you to access array elements at a positive or negative index, avoiding the need for workarounds like arr[arr.length - 1] to access the last element.
const arr = [1, 2, 3, 4, 5];
console.log(; // 1
console.log(; // 5
  1. Intl.RelativeTimeFormat():
    This object, introduced in ES2020, formats a relative time according to the rules of the given locale and options. It’s particularly useful for displaying human-readable timestamps.
const rtf = new Intl.RelativeTimeFormat('en', { style: 'narrow' });
const past = rtf.format(-2, 'day'); // '2d ago'
const future = rtf.format(5, 'hour'); // 'in 5h'

These are just a few examples of lesser-known but handy JavaScript features. With each new ECMAScript release, the language continues to evolve, bringing more powerful and expressive features to developers.


Let’s break down the responses and see who offered the most insightful JavaScript tips.

Gemini 1.0 Pro

  • Strengths:
    • Covers a diverse set of tips, from object manipulation to regular expressions.
    • Demonstrates a strong grasp of language fundamentals.
    • Introduces less common concepts like lookarounds and Symbols.
  • Weaknesses:
    • Some explanations are a bit too technical, potentially losing some less experienced readers.

ChatGPT 3.5

  • Strengths:
    • Gives detailed explanations with a focus on potential performance benefits.
    • Shows a good understanding of advanced concepts like Memoization and Proxies.
    • Highlights using Chrome DevTools for debugging, a crucial skill for senior devs.
  • Weaknesses:
    • The deepFreeze function might be overly complex for the given task.
    • While powerful, Proxies might be too niche for many senior developer’s everyday needs.

Claude 3 Sonnet

  • Strengths:
    • Provides clear and concise explanations.
    • Offers practical, real-world use cases.
    • Includes a mix of newer features (Optional Chaining, Nullish Coalescing) and more established techniques (Array methods).
  • Weaknesses:
    • Some of the examples might be considered too basic for senior engineers.

And the Winner Is…

It’s a close call! There’s no single “best” answer, as the most valuable response would depend on the reader’s experience level and specific interests. However, here’s a possible breakdown:

  • Best for a Well-Rounded View: Gemini’s response offers the most diverse set of tips, potentially sparking new ideas for experienced developers.
  • Best for Practicality: Claude’s response focuses on immediately usable techniques with clear examples.
  • Best for Deep Dive: ChatGPT provides the most in-depth and performance-focused explanations, ideal for developers who want to optimize their code.


Each AI demonstrated its strengths in responding to the prompt. This highlights how different language models can provide complementary value depending on the developer’s needs.

So, which AI had your favorite tips? Leave a comment and share your thoughts below!

Leave a Reply

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