Swift/Parse转React：模仿@NSManaged的JS/TS属性装饰器实现问题

Got it, let's break down how to replicate that Swift Parse subclass behavior in JavaScript/React Native with Parse-React.

First, let's recap what your Swift code does: by subclassing PFObject and using @NSManaged, you're creating a strongly-typed model that maps directly to your Parse "FooModel" class, with automatic handling of Parse's managed properties. That's a clean way to work with Parse data in Swift—now let's get the same feel in JS.

1. Basic Parse Subclassing (Closest to Your Swift Setup) #

Parse's JavaScript SDK supports subclassing Parse.Object directly, which is the direct parallel to your Swift PFObject subclass. Here's how to set it up:

// Define the subclass
const FooModel = Parse.Object.extend('FooModel', {
  // Add instance methods here if you need them
}, {
  // Add class-level methods here (like parseClassName() in Swift)
});

// Register the subclass with Parse (critical for proper functionality)
Parse.Object.registerSubclass('FooModel', FooModel);

// Usage example
const foo = new FooModel();
foo.set('name', 'My First Foo');
await foo.save();

// Retrieve the property
const fooName = foo.get('name');

This registers your class with Parse just like parseClassName() does in Swift, ensuring Parse recognizes it when fetching or saving data.

2. Getters/Setters for @NSManaged-Style Property Access #

If you want to avoid using get()/set() every time and instead use clean dot notation (like foo.name), you can add custom getters and setters to your subclass:

const FooModel = Parse.Object.extend('FooModel', {
  get name() {
    return this.get('name');
  },
  set name(value) {
    this.set('name', value);
  }
});

Parse.Object.registerSubclass('FooModel', FooModel);

// Now you can use it like this:
const foo = new FooModel();
foo.name = 'My Typed Foo';
console.log(foo.name); // Outputs "My Typed Foo"
await foo.save();

This gives you the same intuitive property access you get with @NSManaged in Swift—no more clunky method calls for basic property operations.

3. Fixing Your Decorator Approach #

If your custom decorator didn't work as expected, it's because Parse's JS SDK doesn't natively support decorator-based property mapping like Swift does. But you can build a custom decorator that automates adding getters/setters for you. Here's a working example:

// Custom decorator to mimic @NSManaged
function parseProperty(fieldName) {
  return function(target, propertyKey) {
    Object.defineProperty(target, propertyKey, {
      get() {
        return this.get(fieldName);
      },
      set(value) {
        this.set(fieldName, value);
      },
      enumerable: true,
      configurable: true
    });
  };
}

// Use the decorator in your subclass
class FooModel extends Parse.Object {
  constructor() {
    super('FooModel');
  }

  @parseProperty('name')
  name;
}

Parse.Object.registerSubclass('FooModel', FooModel);

// Usage stays clean:
const foo = new FooModel();
foo.name = 'Decorator-Powered Foo';
await foo.save();

Note: For this to work, your environment needs to support ES decorators and class fields. If you're using React Native, you might need to enable these features via Babel or TypeScript config.

Key Takeaways #

• The core equivalent to your Swift PFObject subclass is extending Parse.Object in JS.
• Getters/setters replicate the clean property access of @NSManaged.
• Custom decorators can automate this, but require extra setup since Parse JS doesn't include this out of the box.

If you hit snags with any part of this migration—like subclass registration or decorator config—feel free to dive into the specifics!

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