Versprechen als Klassenmethode Aufruf triggert object.then beim Auflösen

Question

Ich habe eine Klasse, die db-Methoden enthält und es ist in einem Proxy eingewickelt, der den Zugriff auf Eigenschaften behandelt. Da das Thema verspricht hier bezogen wird, ist ein vereinfachtes Beispiel-Code, der das gleiche Problem reproduziert:

const handler = { 
    ownKeys(target) { 
    return Object.keys(target._attributes) 
    }, 
    get(target, property) { 
    console.log(`<-${property}`) // <-- this logs what properties are being accessed 
    if (typeof target[property] !== 'undefined') { 
     return Reflect.get(target, property) 
    } 
    return Reflect.get(target._attributes, property) 
    }, 
    set(target, property, value) { 
    target._attributes[property] = value 
    return true 
    } 
} 
class User { 
    static table = 'users' 
    static fetch(query = {}, opts = {}) { 
     return new Promise((resolve, reject) => { 
      setTimeout(() => { 
      resolve(new this(query)) 
      }, 500) 
     }) 
    } 
    constructor(attributes = {}) { 
     this._attributes = attributes 
     return new Proxy(this, handler) 
    } 
} 
async function trigger() { 
    const user = await User.fetch({test:'test'}) 
    console.log(JSON.stringify(user._attributes)) 
} 
trigger() 

Alles funktioniert gut, während der Test ich einen Ausdruck an den Proxy hinzugefügt haben Performance-Einbußen der Verwendung eines solchen zu bestimmen, Modellentwurf, und ich bemerkte, dass mein Modell aus der Versprechungskette heraus aufgerufen wird.

Beispielausgabe folgt:

<-then 
<-_attributes 
{"test":"test"} 

Ich denke, dass new this(query) Rückkehr die Versprechungen verursacht vielleicht zu denken, dass es ein Versprechen zurück und folglich .then() ausgeführt wird. einzige Lösung, die ich gefunden habe, ist, wie diese Entschlossenheit Antwort innerhalb neues Array oder ein anderes Objekt zu wickeln:

static fetch(query = {}, opts = {}) { 
    return new Promise((resolve, reject) => { 
    setTimeout(() => { 
     resolve([new this(query)]) 
    }, 500) 
    }) 
} 
// Output 
// 2 
// <-_attributes 
// {"test":"test"} 

Was ich frage mich, ist dies richtige Weg, und es gibt auch andere Lösungen für diese Nebenwirkung?

Answer 1

Alle Objekte, die als Ergebnis eines Versprechens übergeben werden, werden immer daraufhin überprüft, ob sie eine then Eigenschaft besitzen. Wenn dies der Fall ist, wird diese Funktion verwendet, um Einträge in die Warteschlange zu stellen, um einen endgültigen Wert zu erhalten. Aus diesem Grund Logik wie

Promise.resolve() 
    .then(() => { 
     return Promise.resolve(45); 
    }) 
    .then(result => { 
     console.log(result); 
    }); 

logs 45 anstelle eines Versprechens Objekt. Da die Promise-Objekte eine .then-Eigenschaft haben, wird sie verwendet, um den Versprechenswert auszupacken. Das gleiche Verhalten passiert in Ihrem Fall resolve(new this(query)), weil es wissen muss, ob es einen Wert zum Auspacken gibt.

Wie Sie gesagt haben, in Ihrem Beitrag kommentiert, könnten Sie sicherlich die Instanz mit einem Nicht-Proxy, z.

resolve({ value: new this(query) }) 

die für .then auf dass Objekt überprüfen würde, anstatt auf Ihrem Proxy, aber dann haben Sie .value zu tun, um tatsächlich den Proxy zu bekommen, die ein Schmerz sein kann.

Am Ende des Tages, das ist eine Wahl, die Sie treffen müssen.