Kurze Analyse der Einführung und grundlegenden Verwendung von Promise

neues Versprechen()

var Versprechen = neues Versprechen ((lösen, ablehnen) => {
    // Es wird verwendet, um asynchrone Operationen zu handhaben})

var Versprechen = neues Versprechen ((lösen, ablehnen) => {
    // Dies ist eine asynchrone Operation setTimeout(() => {
        // Hier wird das Erhalten der Daten simuliert var data = 'erhaltene Daten'
        // Nachdem wir die Daten erhalten haben, können wir die Methoden „Resolve“ und „Reject“ aufrufen, um den Status des Promise-Objekts zu ändern. „Resolve“ (Daten) // „Resolve“ kann den Status des Promise-Objekts auf „Erfolgreich“ ändern, „Reject()“ kann den Status des Promise-Objekts auf „Fehler“ ändern. }, 1000);
})

versprechen.dann(Wert => {
// Wenn resolve(data) in der asynchronen Funktion aufgerufen wird, das heißt, wenn der Status des Promise-Objekts erfolgreich ist, wird der erste Parameter der then-Methode console.log(value) aufgerufen; // Der Wert „Hallo Welt“ sind die von der Methode resolve() übergebenen Daten}, err => {
   // Wenn reject(data) in der asynchronen Funktion aufgerufen wird, d. h. wenn der Status des Promise-Objekts fehlgeschlagen ist, wird der zweite Parameter der then-Methode console.log(err) aufgerufen; // err sind die von der reject()-Methode übergebenen Daten})

lass Daten = Versprechen.dann((Wert) => {
    // konsole.log(Wert.Ergebnis);
    // Nicht-Promise zurückgeben // val.result zurückgeben
 
    // Versprechen zurückgeben return new Promise( (auflösen, ablehnen) => {
        // auflösen('ok')
        ablehnen('fehler')
    })
}, err => {
console.log(fehler);
})
// Gibt ein Nicht-Promise zurück und der Status ist Erfolg. Der Rückgabewert ist der Erfolgswert des Objekts. // Das Rückgabeergebnis ist ein Promise-Objekt. Der Objektstatus wird durch das Ausführungsergebnis der Rückruffunktion bestimmt. // Löst einen Fehler aus und der Status ist Fehlschlag. console.log(data);

const promise = neues Versprechen((lösen, ablehnen) => {
    lösen('ok')
})
versprechen.dann(val => {
    console.log(Wert); // ok
}).catch(err => {
    console.log(fehler);
})

const promise = neues Versprechen((lösen, ablehnen) => {
    ablehnen('fehler')
})
versprechen.dann(val => {
    konsole.log(Wert);
}).catch(err => {
    console.log(err); // Fehler
})

const promise = neues Versprechen((lösen, ablehnen) => {
    lösen('Fehler')
})
versprechen.dann(val => {
    console.log('ok'); // ok
    werfen Sie „Etwas ist schiefgelaufen!“ ! ' // Dann auftretende Fehler werden weiterhin von catch abgefangen}).catch(err => {
    console.log(err); // Etwas ist schiefgelaufen! !
})

const promise = neues Versprechen((lösen, ablehnen) => {
    lösen('ok')
})
versprechen.dann(val => {
    returniere neues Promise((lösen, ablehnen) => {
        ablehnen('fehler')
    })
})
.then(val => {
    returniere neues Promise((lösen, ablehnen) => {
        ablehnen('fehler')
    })
})
.catch(err => {
    // Alle oben generierten Fehler können mit „catch console.log(err);“ abgefangen werden. // err
})

// Dateiinformationen lesen const fs = require('fs')

// Dateiinformationen lesen const fs = require('fs')
 
// Wenn das Lesen fehlschlägt, ist „err“ ein Fehlerobjekt, und wenn das Lesen erfolgreich ist, sind „data“ die Daten fs.readFile('./01.txt', (err, data) => {
    // Bestimmen Sie, ob ein Fehler auftritt. Wenn ein Fehler auftritt, drucken Sie das Fehlerobjekt.
    wenn (Fehler) {
        console.log(fehler);
        zurückkehren
    }
    Konsole.log(Daten.toString());
})

// Dateiinformationen lesen const fs = require('fs')
 
const promise = neues Versprechen((lösen, ablehnen) => {
    fs.readFile('./01.txt', (err, data) => {
        wenn (Fehler) returniere ablehnen(Fehler)
        auflösen (Daten)
    })
})
 
versprechen.dann(val => {
    console.log(val.toString());
    //Gibt ein Promise-Objekt zurück return new Promise((resolve, reject) => {
        fs.readFile('./02.txt', (err, data) => {
            wenn (Fehler) returniere ablehnen(Fehler)
            auflösen (Daten)
        })
    })
}, err => {
    console.log(fehler);
})
// Das vorherige gibt dann ein Promise-Objekt zurück, wir können fortfahren.
.then(val => {
    console.log(val.toString());
    returniere neues Promise((lösen, ablehnen) => {
        fs.readFile('./03.txt', (err, data) => {
            wenn (Fehler) returniere ablehnen(Fehler)
            auflösen (Daten)
        })
    })
}, err => {
    console.log(fehler);
})
.then(val => {
    console.log(val.toString());
}, err => {
    console.log(fehler);
})

const promise = neues Versprechen((lösen, ablehnen) => {
    // Objekt erstellen const xhr = new XMLHttpRequest()
    // Initialisieren Sie xhr.open("GET", 'https://api.apiopen.top/getSongPoetry?page=1&count=20')
    // Senden Sie xhr.send()
    // Bind-Ereignisverarbeitungsantwortergebnis xhr.onreadystatechange = function () {
        // Beurteilung // Beim Eintritt in die letzte Phase werden alle Antworttexte zurückgegeben, wenn (xhr.readyState === 4) {
            // Bestimmen Sie den Antwortcode, wenn (xhr.status >= 200 && xhr.status < 300) {
                // Zeigt Erfolg an // console.log(JSON.parse(xhr.response));
                auflösen(JSON.parse(xhr.response))
            } anders {
                ablehnen(xhr.status)
            }
        }
    }
})
// Rückrufversprechen angeben.then((val) => {
    konsole.log(Wert);
}, err => {
    console.log(fehler);
})