Node.js（或 JavaScript）中的 @JsonProperty 等价物是什么？

Question

我想在 Node.js（或 JavaScript）中重命名 json 对象的键。 就像我们如何使用 @JsonProperty 在 java 中重命名一样，在 JavaScript 中是否有等效的东西来做同样的事情？

我在 java 中编写了以下代码来更改 json object 的键名（从大写到驼峰）。

public class Rename {
    @JsonProperty("STUDENT_ID")
    private String studentId;
    @JsonProperty("STUDENT_NAME")
    private String studentName;

    public String getStudentId() {
        return studentId;
    }

    public void setStudentId(String studentId) {
        this.studentId = studentId;
    }

    public String getStudentName() {
        return studentName;
    }

    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }

    @Override
    public String toString() {
        return "{" + 
                 "\"studentId\":\"" + studentId + '\"' +
                 ", \"studentName\":\"" + studentName + '\"' +
               '}';
    }

}

我想在 Node.js 中做同样的事情。是否有任何注释或任何方法可以做到这一点？

这是我到目前为止所做的：

class Rename {
    studentId = '';
    studentName = '';

    getStudentId = function() {
        return studentId;
    }

    setStudentId = function(studentId) {
        this.studentId = studentId;
    }

    getStudentName = function() {
        return studentName;
    }

    setStudentName = function(studentName) {
        this.studentName = studentName;
    }

    // I'm not sure how to write toString() function
}

const info = require('./file.json')
info.forEach(node => {
    let n = node;
    let obj = new Rename();
    // I am confused how to call toString()
}

file.json 看起来像：

[
  {
    "STUDENT_ID": "1",
    "STUDENT_NAME" "abc"
  },
  {
    "STUDENT_ID": "2",
    "STUDENT_NAME" "xyz"
  }
]

我希望 output 是：

[
  {
    "studentId": "1",
    "studentName" "abc"
  },
  {
    "studentId": "2",
    "studentName" "xyz"
  }
]

Answer 1

JavaScript 中没有等效项。

@JsonProperty来自Jackson 库，所以它甚至不是 Java 的一部分。它是序列化器/反序列化器重命名属性的一种便利。

可以定义自定义 function 来重命名属性：

 const renamer = (mappings, obj) => Object.fromEntries( Object.entries(obj).map(([key, value]) => [mappings.get(key)?? key, value]) ); const student = { studentId: "123", studentName: "Fred" }; const studentMappings = new Map().set("studentId", "STUDENT_ID").set("studentName", "STUDENT_NAME"); const renamed = renamer(studentMappings, student); console.log(renamed);

并且可以为数据类型创建序列化器/反序列化器对：

 const renamer = (mappings, obj) => Object.fromEntries( Object.entries(obj).map(([key, value]) => [mappings.get(key)?? key, value]) ); const invertMap = map => new Map(Array.from(map, ([k, v]) => [v, k])); const dataHandler = mappings => ({ serialiser: obj => JSON.stringify(renamer(mappings, obj)), deserialiser: json => renamer(invertMap(mappings), JSON.parse(json)) }); const student = { studentId: "123", studentName: "Fred" }; const studentMappings = new Map().set("studentId", "STUDENT_ID").set("studentName", "STUDENT_NAME"); const studentDataHandler = dataHandler(studentMappings); const serialised = studentDataHandler.serialiser(student); console.log("serialised:", serialised); console.log("deserialised:", studentDataHandler.deserialiser(serialised));

 .as-console.wrapper { max-height: 100%;important; }

对于仅序列化，这可以通过提供自定义Object#toJSON()方法来更接近 Jackson 的行为，该方法将在使用JSON.stringify()序列化时自动调用。

可以定义一个通用的 function，目的是在许多对象上重复使用。 这个 function 可以使用已知符号从 object 实例中查找映射并继续重命名：

 const renamer = (mappings, obj) => Object.fromEntries( Object.entries(obj).map(([key, value]) => [mappings.get(key)?? key, value]) ); function implicitRename() { const mappings = this[Symbol.for("serialisationMappings")]?? new Map(); return renamer(mappings, this); } const studentMappings = new Map().set("studentId", "STUDENT_ID").set("studentName", "STUDENT_NAME"); const student = { studentId: "123", studentName: "Fred", [Symbol.for("serialisationMappings")]: studentMappings, toJSON: implicitRename }; class StudentClass { get [Symbol.for("serialisationMappings")]() { return studentMappings; } constructor(id, name) { this.studentId = id; this.studentName = name; } toJSON() { return implicitRename.call(this); } } const serialisedPlainObject = JSON.stringify(student); console.log("serialised plain object:", serialisedPlainObject); const studentInstance = new StudentClass("321", "Barney"); const serialisedClassInstance = JSON.stringify(studentInstance); console.log("serialised class instance object:", serialisedClassInstance);

 .as-console.wrapper { max-height: 100%;important; }

可以看出，这可以对类和普通对象起作用。 但是，它只是单向的：当序列化为 JSON 时。从 JSON 到 object 的转换（当使用JSON.parse()时）通常无法完成，因为 JSON 结果不提供有关类型或要使用的映射的信息.

如果定义了 function 来反序列化每种类型，则可以使用类似于上面的dataHandler实现的东西。

具体对于类，可以提供一个 static fromJSON()方法，它将知道映射是什么。 但是，实现需要根据 object 有所不同。例如，对于StudentClass ，它可能看起来像这样，但其他类可能需要其他方式来实例化（从工厂方法或其他方式）：

class StudentClass{
  /* ... */
  static fromJSON(json) {
    const obj = JSON.parse(json);
    
    return new StudentClass(obj.STUDENT_ID, obj.STUDENT_NAME);
  }
}