为何Karate特性无法访问用class创建的JS对象方法？

Let me break down why this happens and how you can fix it while sticking to clean ES6 syntax.

The Root Cause #

When you return your config object from karate-config.js, Karate processes it in a way that only retains an object's own enumerable properties. ES6 class methods are defined on the class prototype, not directly on the instance itself. Since these prototype methods aren't part of the instance's own properties, they get stripped out when Karate passes the config to your feature file.

Your old-school constructor works because you assign the bar method directly to this—making it an own enumerable property of the instance, so Karate keeps it intact.

ES6-Friendly Fixes #

You don't have to abandon classes entirely. Here are a few ways to make your class methods accessible in features while keeping that modern syntax:

1. Define Methods as Instance Properties in the Constructor #

This mirrors your working old-style approach but uses ES6 arrow functions:

function fn() {
  class My {
    constructor(foo) {
      this.foo = foo;
      // Attach method directly to the instance
      this.bar = () => this.foo;
    }
  }

  const my = new My("x");
  karate.log(my.bar()); // prints "x"

  return { my };
}

The arrow function preserves the correct this context, and since it's assigned to this, it becomes an own property that Karate won't strip out.

2. Copy Prototype Methods to the Instance #

If you prefer keeping methods in the class definition, explicitly copy prototype methods to the instance in the constructor:

function fn() {
  class My {
    constructor(foo) {
      this.foo = foo;
      // Copy prototype methods to make them instance-owned
      Object.assign(this, My.prototype);
    }

    bar() {
      return this.foo;
    }
  }

  const my = new My("x");
  karate.log(my.bar()); // prints "x"

  return { my };
}

This way you maintain the class structure while ensuring methods are part of the instance's own properties.

3. Use an ES6 Factory Function #

If classes feel restrictive here, a factory function is another clean ES6 option that avoids prototype chain issues entirely:

function fn() {
  const createMy = (foo) => {
    const bar = () => foo;
    return { foo, bar };
  };

  const my = createMy("x");
  karate.log(my.bar()); // prints "x"

  return { my };
}

Factory functions return objects with all methods as direct, own properties, so Karate will preserve them in the config.

Verification #

Whichever method you choose, when you run your feature, you'll see the bar method appear in the printed object, and calling my.bar() will return the expected value:

[print] {
  "foo": "x",
  "bar": "com.intuit.karate.graal.JsValue$SharableMembersAndInstantiable@..."
}
[print] x

内容的提问来源于stack exchange，提问作者droptix