Util-Modul im node.js-Tutorial-Beispiel – detaillierte Erklärung

Ausgehend von der Typbeurteilung

In JavaScript ist die Überprüfung von Variablentypen sehr mühsam. Wenn Sie einfach typeof treten verschiedene Probleme auf.

Hier sind einige einfache:

console.log(Typ von null) // 'Objekt'
console.log(Typ des neuen Arrays) // 'Objekt'
console.log(Typ des neuen Strings) // 'Objekt'

Später entdeckten alle, dass Object.prototype.toString() verwendet werden konnte, um den Variablentyp zu bestimmen.

const getTypeString = obj => Object.prototype.toString.call(obj)
 
getTypeString(null) // '[Objekt Null]'
getTypeString('string') //'[Objekt String]'
getTypeString(neuer String) //'[Objekt String]'

Durch Proxying toString() können wir einen Typstring erhalten und mit diesem String etwas anfangen.

const getTypeString = obj => {
  gibt Object.prototype.toString.call(obj) zurück
}
const istTyp = Typ => {
  return obj => {
    return getTypeString(obj) === `[Objekt ${Typ}]`
  }
} 
const isArray = isType('Array') // Diese Methode wird grundsätzlich durch Array.isArray ersetzt const isNull = isType('Null')
const isObject = isType('Objekt')
const isRegExp = isType('RegExp')
const isFunction = isType('Funktion')
const isAsyncFunction = isType('AsyncFunction')
isNull(null) // wahr
isObject({}) // wahr
isRegExp(/\w/) // wahr
istFunktion(() => {}) // wahr
istAsyncFunktion(async () => {}) // wahr

Aber in Node.js gibt es tatsächlich eine Reihe von APIs zum Bestimmen von Variablentypen. Und es verfügt über äußerst umfangreiche Funktionen. Neben der Beurteilung grundlegender Typen unterstützt es auch die Beurteilung von Promise-Objekten, Date-Objekten und verschiedenen ArrayBuffern.

const-Typen = erfordern('util/Typen')
Typen.isDate(neues Datum) // wahr
Typen.isPromise(neues Promise(() => {})) // wahr
Typen.isArrayBuffer(neuer ArrayBuffer(16)) // wahr

Strikte Gleichheit

Wenn in JavaScript die Gleichheit von Objekten, Arrays und anderen Variablen beurteilt wird und === verwendet wird, wird normalerweise nur beurteilt, ob die beiden Variablen auf dieselbe Speicheradresse verweisen. Wenn Sie feststellen möchten, ob alle den Schlüsseln der Objekte entsprechenden Werte gleich sind, müssen Sie die beiden Objekte durchlaufen. In util gibt es auch eine Methode, mit der festgestellt werden kann, ob zwei Objekte strikt gleich sind: util.isDeepStrictEqual(val1, val2)

const util = erfordern('util')
const val1 = { name: 'shenfq' }
const val2 = { name: 'shenfq' } 
console.log('val1 === val2', val1 === val2) // falsch
console.log('isDeepStrictEqual', util.isDeepStrictEqual(Wert1, Wert2)) // wahr

Mit dieser Methode lässt sich auch ermitteln, ob Arrays strikt gleich sind:

const util = erfordern('util')
const arr1 = [1, 3, 5]
const arr2 = [1, 3, 5]
console.log('arr1 === arr2', arr1 === arr2) // falsch
console.log('isDeepStrictEqual', util.isDeepStrictEqual(arr1, arr2)) // wahr

Fehler zuerst und Versprechen

Frühe Node-APIs waren alle Error First Stil, d. h. alle asynchronen Funktionen akzeptierten eine Rückruffunktion, deren Parameter ein Fehlerobjekt war. Wenn das Fehlerobjekt normal zurückgegeben wurde, war es null und die nachfolgenden Parameter waren das Ergebnis einer erfolgreichen Antwort.

// Hier ist ein Beispiel für das Lesen einer Datei const fs = require('fs')
fs.readFile('nginx.log', (Fehler, Daten) => {
  if (Fehler) {
    // Fehler beim Lesen der Datei console.error(error)
    zurückkehren
  }
  // Datei erfolgreich gelesen, Ergebnis ausdrucken console.log(data)
})

Als Node 8 veröffentlicht wurde, wurde eine neue promisify Schnittstelle hinzugefügt, um Error First Stil in die Promise-API zu konvertieren.

const fs = erfordern('fs')
const util = erfordern('util') 
const readFile = util.promisify(fs.readFile)
Datei lesen('./2021-11-11.log', { Kodierung: 'utf-8' })
  .then(text => konsole.log(text)) 
    .catch(Fehler => Konsole.Fehler(Fehler))

Viele Leute waren jedoch später der Meinung, dass die Art und Weise, wie diese nativen APIs Promise unterstützen, zu umständlich ist und jede API mit einer separaten promisify -Methode umschlossen werden muss. Als Node 10 veröffentlicht wurde, wurde den nativen Modulen eine .promises Eigenschaft hinzugefügt und alle APIs unter dieser Eigenschaft sind im Promise-Stil.

const fs = require('fs').versprechen
fs.readFile('./2021-11-11.log', { Kodierung: 'utf-8' })
  .then(text => konsole.log(text)) 
    .catch(Fehler => Konsole.Fehler(Fehler))

Hinweis: Nach Knoten 14 wird eine neue Möglichkeit zum Importieren promises -API hinzugefügt, nämlich der Import durch Ändern des Paketnamens.

const fs = erfordern('fs/versprechen')
fs.readFile('./2021-11-11.log', { Kodierung: 'utf-8' })
  .then(text => konsole.log(text)) 
    .catch(Fehler => Konsole.Fehler(Fehler))

Zusätzlich zur Konvertierung Error First Stil in die Promise-API bietet util auch eine callbackify Methode zum Konvertieren einer async Funktion in eine Funktion Error First Stil.

Als Nächstes wird callbackify verwendet, um das versprochene fs in einer Funktion im Stil Error First wiederherzustellen.

const fs = erfordern('fs/versprechen')
const util = erfordern('util')
const readFile = util.callbackify(fs.readFile)
readFile('./2021-11-12.log', { Kodierung: 'utf-8' }, (Fehler, Text) => {
  if (Fehler) {
    Konsole.Fehler(Fehler)
    zurückkehren
  }
  console.log(text)
})

Debuggen und Ausgabe

Wenn Sie einen Node-Dienst entwickelt haben, sollten Sie das debug verwendet haben, mit dem Sie klarere Debuginformationen in der Konsole sehen können.

const debug = erfordern('debug')
const log = debug('App')
const Benutzer = { Name: 'shenfq' } 
log('Aktueller Benutzer: %o', Benutzer)

Tatsächlich kann ein ähnlicher Effekt durch util.debug erzielt werden:

const debug = erfordern('debug')
const log = debug('App')
const Benutzer = { Name: 'shenfq' } 
log('Aktueller Benutzer: %o', Benutzer)

Ersetzen Sie beim Start einfach die Umgebungsvariable DEBUG durch NODE_DEBUG .

Wenn Sie sich den obigen Code genau ansehen, werden Sie feststellen, dass in der Zeichenfolge vor log('當前用戶: %o', user) ein Platzhalter %o vorhanden ist, der angibt, dass diese Stelle mit einem Objekt gefüllt wird. Dies ähnelt printf in C oder Python. In ähnlicher Weise wird im util Modul die Formatierungsmethode direkt bereitgestellt: util.format .

const { format } = erfordern('util').
konsole.log(
  format('Aktueller Benutzer: %o', {
    Name: 'shenfq', Alter: 25
  })
)

Zusätzlich zum Platzhalter %o sollten für unterschiedliche Datentypen unterschiedliche Platzhalter verwendet werden.

Objekte in JavaScript sind sehr komplex. Neben der direkten Verwendung von util.format mit %o zum Formatieren von Objekten bietet util auch eine Methode namens inspect zum Formatieren von Objekten.

const { inspizieren } = erfordern('util')
const Benutzer = {
  Alter: 25,
  Name: 'shenfq',
  arbeiten:
    Name: 'Kodierung',
    Dienstalter: 5
  }
} 
console.log(inspect(Benutzer))

Es scheint, dass inspect nichts tut, aber die Methode inspect hat einen zweiten Parameter für eine personalisierte Konfiguration während der Formatierung.

depth: number : steuert die Anzeigeebene;

sorted: boolean|Function : ob nach dem codierten Wert des Schlüssels sortiert werden soll;

compact: boolean : ob in einer einzelnen Zeile angezeigt werden soll;

Natürlich ist das oben genannte nur ein Teil der Konfiguration. Eine detailliertere Konfiguration finden Sie in der Knotendokumentation. Nachfolgend schreiben wir ein paar Beispiele:

Alle Eigenschaften werden mit Zeilenumbrüchen angezeigt:

inspizieren(Benutzer, {
    kompakt: falsch
})

Formatieren Sie nur den Wert der ersten Ebene eines Objekts:

inspizieren(Benutzer, {
  Tiefe: 0,
    kompakt: falsch
})

Ausgabe in umgekehrter Reihenfolge entsprechend der Schlüsselwertkodierung:

inspizieren(Benutzer, {
    kompakt: falsch,
  sortiert: (a, b) => a < b ? 1 : -1
})

Oben finden Sie den detaillierten Inhalt des Tutorial-Beispiels des Util-Moduls in node.js. Weitere Informationen zum Util-Modul in node.js finden Sie in den anderen verwandten Artikeln auf 123WORDPRESS.COM!