Aracılığıyla paylaş

util module

Paket:
powerbi-client

node:util modülü, Node.js iç API'lerinin gereksinimlerini destekler. Yardımcı programların çoğu uygulama ve modül geliştiricileri için de yararlıdır. Erişim için:

import util from 'node:util';

Bkz. kaynak

Sınıflar

MIMEParams

MIMEParams API'sinde MIMETypeparametrelerine okuma ve yazma erişimi sağlanır.
MIMEType

MIMEType sınıfıuygulaması.

Tarayıcı kurallarına uygun olarak, MIMEType nesnelerin tüm özellikleri nesnenin kendisinde veri özellikleri olarak değil, sınıf prototipinde alıcı ve ayarlayıcı olarak uygulanır.

MIME dizesi, birden çok anlamlı bileşen içeren yapılandırılmış bir dizedir. Ayrıştırıldığında, bu bileşenlerin her biri için özellikler içeren bir MIMEType nesnesi döndürülür.
TextDecoder

WHATWG Kodlama StandartTextDecoder API'sinin bir uygulaması.

const decoder = new TextDecoder();
const u8arr = new Uint8Array([72, 101, 108, 108, 111]);
console.log(decoder.decode(u8arr)); // Hello
TextEncoder

WHATWG Kodlama StandartTextEncoder API'sinin bir uygulaması. TextEncoder tüm örnekleri yalnızca UTF-8 kodlamayı destekler.

const encoder = new TextEncoder();
const uint8array = encoder.encode('this is some data');

TextEncoder sınıfı genel nesnede de kullanılabilir.

Arabirimler

CallSiteObject
CustomPromisifyLegacy
CustomPromisifySymbol
DebugLogger
EncodeIntoResult
InspectOptions
InspectOptionsStylized
IsDeepStrictEqualOptions
ParseArgsConfig
ParseArgsOptionDescriptor
ParseArgsOptionsConfig
StyleTextOptions

Tür Diğer Adları

CustomInspectFunction
CustomPromisify
DebugLoggerFunction
DiffEntry
ParseArgsOptionsType

parseArgs içinde kullanılan bağımsız değişkenin türü.
Style

İşlevler

aborted(AbortSignal, any)

Sağlanan signal durdurma olayını dinler ve signal durdurulduğunda çözülen bir söz döndürür. resource sağlanırsa, işlemin ilişkili nesnesine zayıf bir şekilde başvurur, bu nedenle resource durdurulmadan önce signal çöp toplanırsa, döndürülen söz beklemede kalır. Bu, uzun süre çalışan veya iptal edilemeyen işlemlerde bellek sızıntılarını önler.

import { aborted } from 'node:util';

// Obtain an object with an abortable signal, like a custom resource or operation.
const dependent = obtainSomethingAbortable();

// Pass `dependent` as the resource, indicating the promise should only resolve
// if `dependent` is still in memory when the signal is aborted.
aborted(dependent.signal, dependent).then(() => {
  // This code runs when `dependent` is aborted.
  console.log('Dependent resource was aborted.');
});

// Simulate an event that triggers the abort.
dependent.on('event', () => {
  dependent.abort(); // This will cause the `aborted` promise to resolve.
});
addParamToUrl(string, string, string)

Verilen URL'ye parametre ekler
assign(any[])

Bir veya daha fazla kaynak nesnedeki tüm numaralandırılabilir özelliklerin değerlerini hedef nesneye kopyalar ve hedef nesneyi döndürür.
autoAuthInEmbedUrl(string)

Ekleme URL'sinin autoAuth=true değerini içerip içermediğini denetler.
callbackify(() => Promise<void>)

bir async işlevi (veya Promisedöndüren bir işlev) alır ve hata öncelikli geri çağırma stilini izleyen bir işlev döndürür; örneğin, son bağımsız değişken olarak (err, value) => ... geri çağırma alır. Geri çağırmada ilk bağımsız değişken reddetme nedeni (veya null çözümlendiyse Promise) ve ikinci bağımsız değişken çözümlenen değer olacaktır.

import { callbackify } from 'node:util';

async function fn() {
  return 'hello world';
}
const callbackFunction = callbackify(fn);

callbackFunction((err, ret) => {
  if (err) throw err;
  console.log(ret);
});

Yazdırılacak:

hello world

Geri çağırma zaman uyumsuz olarak yürütülür ve sınırlı bir yığın izlemesine sahip olur. Geri çağırma oluşursa, işlem bir 'uncaughtException' olayı yayar ve işlenmediyse çıkar.

null bir geri çağırmanın ilk bağımsız değişkeni olarak özel bir anlamı olduğundan, sarmalanmış bir işlev hatalı bir değer içeren bir Promise nedeni olarak reddederse, değer Erroradlı alanda depolanan özgün değerle bir reason sarmalanır.

function fn() {
  return Promise.reject(null);
}
const callbackFunction = util.callbackify(fn);

callbackFunction((err, ret) => {
  // When the Promise was rejected with `null` it is wrapped with an Error and
  // the original value is stored in `reason`.
  err && Object.hasOwn(err, 'reason') && err.reason === null;  // true
});
callbackify<T1, T2, T3, T4, T5, T6, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>)
callbackify<T1, T2, T3, T4, T5, T6>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>)
callbackify<T1, T2, T3, T4, T5, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>)
callbackify<T1, T2, T3, T4, T5>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>)
callbackify<T1, T2, T3, T4, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>)
callbackify<T1, T2, T3, T4>((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>)
callbackify<T1, T2, T3, TResult>((arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>)
callbackify<T1, T2, T3>((arg1: T1, arg2: T2, arg3: T3) => Promise<void>)
callbackify<T1, T2, TResult>((arg1: T1, arg2: T2) => Promise<TResult>)
callbackify<T1, T2>((arg1: T1, arg2: T2) => Promise<void>)
callbackify<T1, TResult>((arg1: T1) => Promise<TResult>)
callbackify<T1>((arg1: T1) => Promise<void>)
callbackify<TResult>(() => Promise<TResult>)
createRandomString()

Rastgele 5 ile 6 karakterlik bir dize oluşturur.
debuglog(string, (fn: DebugLoggerFunction) => void)

util.debuglog() yöntemi, ortam değişkeninin varlığına stderr bağlı olarak hata ayıklama iletilerini koşullu olarak yazan bir işlev oluşturmak için NODE_DEBUG kullanılır. section adı bu ortam değişkeninin değeri içinde görünüyorsa, döndürülen işlev console.error()benzer şekilde çalışır. Değilse, döndürülen işlev bir no-opolur.

import { debuglog } from 'node:util';
const log = debuglog('foo');

log('hello from foo [%d]', 123);

Bu program ortamdaki NODE_DEBUG=foo ile çalıştırılırsa şuna benzer bir çıkış oluşturur:

FOO 3245: hello from foo [123]

burada 3245 işlem kimliğidir. Bu ortam değişkeni kümesiyle çalıştırılmazsa hiçbir şey yazdırmaz.

section joker karakteri de destekler:

import { debuglog } from 'node:util';
const log = debuglog('foo');

log('hi there, it\'s foo-bar [%d]', 2333);

ortamda NODE_DEBUG=foo* ile çalıştırılırsa şuna benzer bir çıkış oluşturur:

FOO-BAR 3257: hi there, it's foo-bar [2333]

Ortam değişkeninde section birden çok virgülle ayrılmış NODE_DEBUG ad belirtilebilir: NODE_DEBUG=fs,net,tls.

İsteğe bağlı callback bağımsız değişkeni, günlük işlevini başlatma veya gereksiz kaydırma içermeyen farklı bir işlevle değiştirmek için kullanılabilir.

import { debuglog } from 'node:util';
let log = debuglog('internals', (debug) => {
  // Replace with a logging function that optimizes out
  // testing if the section is enabled
  log = debug;
});
deprecate<T>(T, string, string)

util.deprecate() yöntemi, fn (işlev veya sınıf olabilir) kullanım dışı olarak işaretlenecek şekilde sarmalar.

import { deprecate } from 'node:util';

export const obsoleteFunction = deprecate(() => {
  // Do something here.
}, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');

çağrıldığında, util.deprecate()DeprecationWarning olayını kullanarak bir 'warning' yayacak bir işlev döndürür. Uyarı gönderilir ve döndürülen işlevin ilk çağrılışında stderr yazdırılır. Uyarı gönderildikten sonra sarmalanan işlev bir uyarı yaymadan çağrılır.

aynı isteğe bağlı codeutil.deprecate()için birden çok çağrıda sağlanırsa, uyarı bu codeiçin yalnızca bir kez gönderilir.

import { deprecate } from 'node:util';

const fn1 = deprecate(
  () => 'a value',
  'deprecation message',
  'DEP0001',
);
const fn2 = deprecate(
  () => 'a  different value',
  'other dep message',
  'DEP0001',
);
fn1(); // Emits a deprecation warning with code DEP0001
fn2(); // Does not emit a deprecation warning because it has the same code

veya komut satırı bayrakları kullanılırsa veya özelliği ilk kullanımdan kaldırma uyarısına önce olarak ayarlanırsa, yöntemi hiçbir şey yapmaz.

--trace-deprecation veya --trace-warnings komut satırı bayrakları ayarlanırsa veya process.traceDeprecation özelliği trueolarak ayarlanırsa, kullanım dışı bırakılan işlev ilk çağrılırken stderr için bir uyarı ve yığın izlemesi yazdırılır.

--throw-deprecation komut satırı bayrağı ayarlanırsa veya process.throwDeprecation özelliği trueolarak ayarlanırsa, kullanım dışı bırakılan işlev çağrıldığında bir özel durum oluşturulur.

--throw-deprecation komut satırı bayrağı ve process.throwDeprecation özelliği, --trace-deprecation ve process.traceDeprecation'den önceliklidir.
diff(string | (readonly string[]), string | (readonly string[]))

util.diff() iki dize veya dizi değerini karşılaştırır ve bir fark girdileri dizisi döndürür. Myers fark algoritmasını kullanarak, onaylama hata iletileri tarafından dahili olarak kullanılan aynı algoritma olan en düşük farkları hesaplar.

Değerler eşitse boş bir dizi döndürülür.

const { diff } = require('node:util');

// Comparing strings
const actualString = '12345678';
const expectedString = '12!!5!7!';
console.log(diff(actualString, expectedString));
// [
//   [0, '1'],
//   [0, '2'],
//   [1, '3'],
//   [1, '4'],
//   [-1, '!'],
//   [-1, '!'],
//   [0, '5'],
//   [1, '6'],
//   [-1, '!'],
//   [0, '7'],
//   [1, '8'],
//   [-1, '!'],
// ]
// Comparing arrays
const actualArray = ['1', '2', '3'];
const expectedArray = ['1', '3', '4'];
console.log(diff(actualArray, expectedArray));
// [
//   [0, '1'],
//   [1, '2'],
//   [0, '3'],
//   [-1, '4'],
// ]
// Equal values return empty array
console.log(diff('same', 'same'));
// []
find<T>((x: T) => boolean, T[])

Belirtilen koşulla eşleşen bir dizideki ilk değeri bulur.
findIndex<T>((x: T) => boolean, T[])

Belirtilen koşulla eşleşen bir dizideki ilk değerin dizinini bulur.
format(any, any[])

util.format() yöntemi, ilk bağımsız değişkeni sıfır veya daha fazla biçim tanımlayıcısı içerebilen printfbiçim dizesi olarak biçimlendirilmiş bir dize döndürür. Her tanımlayıcı, karşılık gelen bağımsız değişkenden dönüştürülen değerle değiştirilir. Desteklenen tanımlayıcılar şunlardır:

Tanımlayıcının karşılık gelen bağımsız değişkeni yoksa, değiştirilmez:

util.format('%s:%s', 'foo');
// Returns: 'foo:%s'

Biçim dizesinin parçası olmayan değerler, türleri util.inspect()değilse string kullanılarak biçimlendirilir.

util.format() yöntemine tanımlayıcı sayısından daha fazla bağımsız değişken geçirilirse, fazladan bağımsız değişkenler döndürülen dizeye boşluklarla ayrılmış olarak birleştirilir:

util.format('%s:%s', 'foo', 'bar', 'baz');
// Returns: 'foo:bar baz'

İlk bağımsız değişken geçerli bir biçim tanımlayıcısı içermiyorsa, util.format() boşluklarla ayrılmış tüm bağımsız değişkenlerin birleşimi olan bir dize döndürür:

util.format(1, 2, 3);
// Returns: '1 2 3'

util.format()yalnızca bir bağımsız değişken geçirilirse, herhangi bir biçimlendirme olmadan döndürülür:

util.format('%% %s');
// Returns: '%% %s'

util.format(), hata ayıklama aracı olarak amaçlanan zaman uyumlu bir yöntemdir. Bazı giriş değerleri, olay döngüsünü engelleyebilecek önemli bir performans yüküne sahip olabilir. Bu işlevi dikkatli kullanın ve hiçbir zaman sık erişimli kod yolunda kullanmayın.
formatWithOptions(InspectOptions, any, any[])

Bu işlev,biçimiyle aynıdır, ancakincelemek geçirilecek seçenekleri belirten bir bağımsız değişkeni alır.

util.formatWithOptions({ colors: true }, 'See object %O', { foo: 42 });
// Returns 'See object { foo: 42 }', where `42` is colored as a number
// when printed to a terminal.
generateUUID()

20 karakterlik uuid oluşturur.
getCallSites(GetCallSitesOptions)
getCallSites(number, GetCallSitesOptions)

Çağıran işlevinin yığınını içeren bir çağrı sitesi nesneleri dizisi döndürür.

import { getCallSites } from 'node:util';

function exampleFunction() {
  const callSites = getCallSites();

  console.log('Call Sites:');
  callSites.forEach((callSite, index) => {
    console.log(`CallSite ${index + 1}:`);
    console.log(`Function Name: ${callSite.functionName}`);
    console.log(`Script Name: ${callSite.scriptName}`);
    console.log(`Line Number: ${callSite.lineNumber}`);
    console.log(`Column Number: ${callSite.column}`);
  });
  // CallSite 1:
  // Function Name: exampleFunction
  // Script Name: /home/example.js
  // Line Number: 5
  // Column Number: 26

  // CallSite 2:
  // Function Name: anotherFunction
  // Script Name: /home/example.js
  // Line Number: 22
  // Column Number: 3

  // ...
}

// A function to simulate another stack layer
function anotherFunction() {
  exampleFunction();
}

anotherFunction();

sourceMap seçeneğini trueolarak ayarlayarak özgün konumları yeniden yapılandırmak mümkündür. Kaynak harita kullanılamıyorsa, özgün konum geçerli konumla aynı olur. örneğin --enable-source-mapskullanıldığında --experimental-transform-types bayrağı etkinleştirildiğinde sourceMap varsayılan olarak true olur.

import { getCallSites } from 'node:util';

interface Foo {
  foo: string;
}

const callSites = getCallSites({ sourceMap: true });

// With sourceMap:
// Function Name: ''
// Script Name: example.js
// Line Number: 7
// Column Number: 26

// Without sourceMap:
// Function Name: ''
// Script Name: example.js
// Line Number: 2
// Column Number: 26
getRandomValue()

Rastgele sayı verir
getSystemErrorMap()

Node.js API'sinden kullanılabilen tüm sistem hata kodlarının haritasını döndürür. Hata kodları ve hata adları arasındaki eşleme platforma bağlıdır. Yaygın hataların adları için bkz. Common System Errors.

fs.access('file/that/does/not/exist', (err) => {
  const errorMap = util.getSystemErrorMap();
  const name = errorMap.get(err.errno);
  console.error(name);  // ENOENT
});
getSystemErrorMessage(number)

Node.js API'sinden gelen sayısal bir hata kodu için dize iletisini döndürür. Hata kodları ve dize iletileri arasındaki eşleme platforma bağlıdır.

fs.access('file/that/does/not/exist', (err) => {
  const message = util.getSystemErrorMessage(err.errno);
  console.error(message);  // no such file or directory
});
getSystemErrorName(number)

Node.js API'sinden gelen sayısal bir hata kodunun dize adını döndürür. Hata kodları ve hata adları arasındaki eşleme platforma bağlıdır. Yaygın hataların adları için bkz. Common System Errors.

fs.access('file/that/does/not/exist', (err) => {
  const name = util.getSystemErrorName(err.errno);
  console.error(name);  // ENOENT
});
getTimeDiffInMilliseconds(Date, Date)

İki tarih arasındaki zaman aralığını milisaniye cinsinden verir
inherits(unknown, unknown)

util.inherits() kullanımı önerilmez. Dil düzeyinde devralma desteği almak için lütfen ES6 class ve extends anahtar sözcüklerini kullanın. Ayrıca, iki stilin uyumsuz olduğunu unutmayın.

Prototip yöntemlerini bir oluşturucudan diğerine devralın. constructor prototipi, superConstructor'den oluşturulan yeni bir nesneye ayarlanır.

Bu, temel olarak üzerine Object.setPrototypeOf(constructor.prototype, superConstructor.prototype)bazı giriş doğrulamaları ekler. Ek bir kolaylık olarak, superConstructorconstructor.super_ özelliği aracılığıyla erişilebilir olacaktır.

const util = require('node:util');
const EventEmitter = require('node:events');

function MyStream() {
  EventEmitter.call(this);
}

util.inherits(MyStream, EventEmitter);

MyStream.prototype.write = function(data) {
  this.emit('data', data);
};

const stream = new MyStream();

console.log(stream instanceof EventEmitter); // true
console.log(MyStream.super_ === EventEmitter); // true

stream.on('data', (data) => {
  console.log(`Received data: "${data}"`);
});
stream.write('It works!'); // Received data: "It works!"

class ve extendskullanan ES6 örneği:

import EventEmitter from 'node:events';

class MyStream extends EventEmitter {
  write(data) {
    this.emit('data', data);
  }
}

const stream = new MyStream();

stream.on('data', (data) => {
  console.log(`Received data: "${data}"`);
});
stream.write('With ES6');
inspect(any, boolean, null | number, boolean)

util.inspect() yöntemi, hata ayıklamaya yönelik object dize gösterimini döndürür. util.inspect çıkışı herhangi bir zamanda değişebilir ve program aracılığıyla bağımlı olmamalıdır. Sonucu değiştiren ek options geçirilebilir. util.inspect() , denetlenen bir değer için tanımlanabilir bir etiket oluşturmak için oluşturucunun adını ve/veya Symbol.toStringTag özelliğini kullanır.

class Foo {
  get [Symbol.toStringTag]() {
    return 'bar';
  }
}

class Bar {}

const baz = Object.create(null, { [Symbol.toStringTag]: { value: 'foo' } });

util.inspect(new Foo()); // 'Foo [bar] {}'
util.inspect(new Bar()); // 'Bar {}'
util.inspect(baz);       // '[foo] {}'

Döngüsel başvurular, bir başvuru dizini kullanarak bağlayıcılarına işaret eder:

import { inspect } from 'node:util';

const obj = {};
obj.a = [obj];
obj.b = {};
obj.b.inner = obj.b;
obj.b.obj = obj;

console.log(inspect(obj));
// <ref *1> {
//   a: [ [Circular *1] ],
//   b: <ref *2> { inner: [Circular *2], obj: [Circular *1] }
// }

Aşağıdaki örnek, util nesnesinin tüm özelliklerini inceler:

import util from 'node:util';

console.log(util.inspect(util, { showHidden: true, depth: null }));

Aşağıdaki örnekte compact seçeneğinin etkisi vurgulanır:

import { inspect } from 'node:util';

const o = {
  a: [1, 2, [[
    'Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit, sed do ' +
      'eiusmod \ntempor incididunt ut labore et dolore magna aliqua.',
    'test',
    'foo']], 4],
  b: new Map([['za', 1], ['zb', 'test']]),
};
console.log(inspect(o, { compact: true, depth: 5, breakLength: 80 }));

// { a:
//   [ 1,
//     2,
//     [ [ 'Lorem ipsum dolor sit amet,\nconsectetur [...]', // A long line
//           'test',
//           'foo' ] ],
//     4 ],
//   b: Map(2) { 'za' => 1, 'zb' => 'test' } }

// Setting `compact` to false or an integer creates more reader friendly output.
console.log(inspect(o, { compact: false, depth: 5, breakLength: 80 }));

// {
//   a: [
//     1,
//     2,
//     [
//       [
//         'Lorem ipsum dolor sit amet,\n' +
//           'consectetur adipiscing elit, sed do eiusmod \n' +
//           'tempor incididunt ut labore et dolore magna aliqua.',
//         'test',
//         'foo'
//       ]
//     ],
//     4
//   ],
//   b: Map(2) {
//     'za' => 1,
//     'zb' => 'test'
//   }
// }

// Setting `breakLength` to e.g. 150 will print the "Lorem ipsum" text in a
// single line.

showHidden seçeneği, WeakMap ve WeakSet girdilerinin denetlenmesini sağlar. maxArrayLength'den daha fazla girdi varsa, hangi girişlerin görüntüleneceğinin garantisi yoktur. Başka bir deyişle aynı WeakSet girdilerinin iki kez alınması farklı çıkışlara neden olabilir. Ayrıca, hiçbir güçlü başvurusu olmayan girdiler herhangi bir zamanda çöp olarak toplanabilir.

import { inspect } from 'node:util';

const obj = { a: 1 };
const obj2 = { b: 2 };
const weakSet = new WeakSet([obj, obj2]);

console.log(inspect(weakSet, { showHidden: true }));
// WeakSet { { a: 1 }, { b: 2 } }

sorted seçeneği, nesnenin özellik ekleme sırasının util.inspect()sonucunu etkilememesini sağlar.

import { inspect } from 'node:util';
import assert from 'node:assert';

const o1 = {
  b: [2, 3, 1],
  a: '`a` comes before `b`',
  c: new Set([2, 3, 1]),
};
console.log(inspect(o1, { sorted: true }));
// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set(3) { 1, 2, 3 } }
console.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));
// { c: Set(3) { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }

const o2 = {
  c: new Set([2, 1, 3]),
  a: '`a` comes before `b`',
  b: [2, 3, 1],
};
assert.strict.equal(
  inspect(o1, { sorted: true }),
  inspect(o2, { sorted: true }),
);

numericSeparator seçeneği, tüm sayılara her üç basamağı bir alt çizgi ekler.

import { inspect } from 'node:util';

const thousand = 1000;
const million = 1000000;
const bigNumber = 123456789n;
const bigDecimal = 1234.12345;

console.log(inspect(thousand, { numericSeparator: true }));
// 1_000
console.log(inspect(million, { numericSeparator: true }));
// 1_000_000
console.log(inspect(bigNumber, { numericSeparator: true }));
// 123_456_789n
console.log(inspect(bigDecimal, { numericSeparator: true }));
// 1_234.123_45

util.inspect(), hata ayıklamaya yönelik zaman uyumlu bir yöntemdir. Maksimum çıkış uzunluğu yaklaşık 128 MiB'dir. Daha uzun çıkışla sonuçlanacak girişler kesilir.
inspect(any, InspectOptions)
isArray(unknown)

Diğer ad için Array.isArray().

Verilen true bir objectise Array döndürür. Aksi takdirde döndürür false.

import util from 'node:util';

util.isArray([]);
// Returns: true
util.isArray(new Array());
// Returns: true
util.isArray({});
// Returns: false
isCreate(string)

Ekleme türünün oluşturma için olup olmadığını denetler
isDeepStrictEqual(unknown, unknown, IsDeepStrictEqualOptions)

true ile val1arasında derin katı eşitlik varsa val2 döndürür. Aksi takdirde döndürür false.

Derin katı eşitlik hakkında daha fazla bilgi için bkz. assert.deepStrictEqual().
isRDLEmbed(string)

Ekleme URL'sinin RDL raporu için olup olmadığını denetler.
isSavedInternal(HttpPostMessage, string, Window)

Raporun kaydedilip kaydedilmediğini denetler.
parseArgs<T>(T)

Komut satırı bağımsız değişken ayrıştırma için doğrudan process.argv etkileşime kıyasla daha yüksek düzeyde bir API sağlar. Beklenen bağımsız değişkenler için bir belirtim alır ve ayrıştırılmış seçenekler ve konumsallar ile yapılandırılmış bir nesne döndürür.

import { parseArgs } from 'node:util';
const args = ['-f', '--bar', 'b'];
const options = {
  foo: {
    type: 'boolean',
    short: 'f',
  },
  bar: {
    type: 'string',
  },
};
const {
  values,
  positionals,
} = parseArgs({ args, options });
console.log(values, positionals);
// Prints: [Object: null prototype] { foo: true, bar: 'b' } []
parseEnv(string)

Kararlılık: 1.1 - Etkin geliştirme Örnek bir .env dosyası verilmiştir:

import { parseEnv } from 'node:util';

parseEnv('HELLO=world\nHELLO=oh my\n');
// Returns: { HELLO: 'oh my' }
promisify((callback: (err?: any) => void) => void)
promisify(Function)
promisify<T1, T2, T3, T4, T5, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void)
promisify<T1, T2, T3, T4, T5>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void)
promisify<T1, T2, T3, T4, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void)
promisify<T1, T2, T3, T4>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void)
promisify<T1, T2, T3, TResult>((arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void)
promisify<T1, T2, T3>((arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void)
promisify<T1, T2, TResult>((arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void)
promisify<T1, T2>((arg1: T1, arg2: T2, callback: (err?: any) => void) => void)
promisify<T1, TResult>((arg1: T1, callback: (err: any, result: TResult) => void) => void)
promisify<T1>((arg1: T1, callback: (err?: any) => void) => void)
promisify<TCustom>(CustomPromisify<TCustom>)

Hata öncelikli yaygın geri çağırma stilini izleyen bir işlev alır; örneğin, son bağımsız değişken olarak (err, value) => ... bir geri çağırma alır ve promises döndüren bir sürüm döndürür.

import { promisify } from 'node:util';
import { stat } from 'node:fs';

const promisifiedStat = promisify(stat);
promisifiedStat('.').then((stats) => {
  // Do something with `stats`
}).catch((error) => {
  // Handle the error.
});

Veya eşdeğer olarak async functionkullanarak:

import { promisify } from 'node:util';
import { stat } from 'node:fs';

const promisifiedStat = promisify(stat);

async function callStat() {
  const stats = await promisifiedStat('.');
  console.log(`This directory is owned by ${stats.uid}`);
}

callStat();

Bir özellik varsa original[util.promisify.custom] değerini promisify döndürür, bkz . Özel promisified functions.

promisify(), original her durumda son bağımsız değişkeni olarak geri çağırmayı alan bir işlev olduğunu varsayar. original bir işlev değilse promisify() bir hata oluşturur. original bir işlevse ancak son bağımsız değişkeni hata öncelikli bir geri çağırma değilse, yine de son bağımsız değişkeni olarak hata öncelikli bir geri çağırma geçirilir.

Sınıf yöntemlerinde veya promisify() kullanan diğer yöntemlerde this kullanılması, özel olarak işlenmediği sürece beklendiği gibi çalışmayabilir:

import { promisify } from 'node:util';

class Foo {
  constructor() {
    this.a = 42;
  }

  bar(callback) {
    callback(null, this.a);
  }
}

const foo = new Foo();

const naiveBar = promisify(foo.bar);
// TypeError: Cannot read properties of undefined (reading 'a')
// naiveBar().then(a => console.log(a));

naiveBar.call(foo).then((a) => console.log(a)); // '42'

const bindBar = naiveBar.bind(foo);
bindBar().then((a) => console.log(a)); // '42'
promisify<TResult>((callback: (err: any, result: TResult) => void) => void)
raiseCustomEvent(HTMLElement, string, any)

Belirtilen HTML öğesinde olay verileriyle özel bir olay oluşturur.
remove<T>((x: T) => boolean, T[])
setTraceSigInt(boolean)

üzerinde SIGINTyığın izlemesi yazdırmayı etkinleştirin veya devre dışı bırakın. API yalnızca ana iş parçacığında kullanılabilir.
stripVTControlCharacters(string)

ANSI kaçış kodları kaldırılmış str döndürür.

console.log(util.stripVTControlCharacters('\u001B[4mvalue\u001B[0m'));
// Prints "value"
styleText(ForegroundColors | BackgroundColors | Modifiers | (ForegroundColors | BackgroundColors | Modifiers)[], string, StyleTextOptions)

Bu işlev, terminalde yazdırma için geçirilen değerini dikkate format alarak biçimlendirilmiş bir metin döndürür. Terminalin özelliklerinin farkındadır ve aracılığıyla NO_COLORNODE_DISABLE_COLORS ayarlanan yapılandırmaya ve FORCE_COLOR ortam değişkenlerine göre hareket eder.

import { styleText } from 'node:util';
import { stderr } from 'node:process';

const successMessage = styleText('green', 'Success!');
console.log(successMessage);

const errorMessage = styleText(
  'red',
  'Error! Error!',
  // Validate if process.stderr has TTY
  { stream: stderr },
);
console.error(errorMessage);

util.inspect.colors, italicve underline gibi metin biçimleri de sağlar ve her ikisini de birleştirebilirsiniz:

console.log(
  util.styleText(['underline', 'italic'], 'My italic underlined message'),
);

Bir biçim dizisi geçirilirken, uygulanan biçimin sırası soldan sağa doğru olur, bu nedenle aşağıdaki stil öncekinin üzerine yazabilir.

console.log(
  util.styleText(['red', 'green'], 'text'), // green
);

Özel biçim değeri none metne ek stil uygulamaz.

Biçimlerin tam listesideğiştiricilerinde bulunabilir.
toUSVString(string)

Herhangi bir vekil kod noktası (veya eşdeğeri, eşleşmeyen vekil kod birimleri) Unicode "değiştirme karakteri" U+FFFD ile değiştirdikten sonra string döndürür.
transferableAbortController()

AbortController aktarılabilir olarak işaretlenmiş ve AbortSignal veya structuredClone()ile kullanılabilen bir postMessage() örneği oluşturur ve döndürür.
transferableAbortSignal(AbortSignal)

Verilen AbortSignal aktarılabilir olarak işaretler, böylecestructuredClone() ve postMessage()ile kullanılabilir.

const signal = transferableAbortSignal(AbortSignal.timeout(100));
const channel = new MessageChannel();
channel.port2.postMessage(signal, [signal]);

İşlev Ayrıntıları

aborted(AbortSignal, any)

Sağlanan signal durdurma olayını dinler ve signal durdurulduğunda çözülen bir söz döndürür. resource sağlanırsa, işlemin ilişkili nesnesine zayıf bir şekilde başvurur, bu nedenle resource durdurulmadan önce signal çöp toplanırsa, döndürülen söz beklemede kalır. Bu, uzun süre çalışan veya iptal edilemeyen işlemlerde bellek sızıntılarını önler.

import { aborted } from 'node:util';

// Obtain an object with an abortable signal, like a custom resource or operation.
const dependent = obtainSomethingAbortable();

// Pass `dependent` as the resource, indicating the promise should only resolve
// if `dependent` is still in memory when the signal is aborted.
aborted(dependent.signal, dependent).then(() => {
  // This code runs when `dependent` is aborted.
  console.log('Dependent resource was aborted.');
});

// Simulate an event that triggers the abort.
dependent.on('event', () => {
  dependent.abort(); // This will cause the `aborted` promise to resolve.
});

function aborted(signal: AbortSignal, resource: any): Promise<void>

Parametreler

signal

AbortSignal

resource

any

Durdurulabilir işleme bağlı ve zayıf tutulan null olmayan herhangi bir nesne. resource durdurulmadan önce signal çöp toplanırsa, söz beklemede kalır ve Node.js izlemeyi durdurmasına izin verir. Bu, uzun süre çalışan veya iptal edilemeyen işlemlerde bellek sızıntılarını önlemeye yardımcı olur.

Döndürülenler

Promise<void>

addParamToUrl(string, string, string)

Verilen URL'ye parametre ekler

function addParamToUrl(url: string, paramName: string, value: string): string

Parametreler

url

string

paramName

string

value

string

Döndürülenler

string

assign(any[])

Bir veya daha fazla kaynak nesnedeki tüm numaralandırılabilir özelliklerin değerlerini hedef nesneye kopyalar ve hedef nesneyi döndürür.

function assign(args: any[]): any

Parametreler

args

any[]

Döndürülenler

any

autoAuthInEmbedUrl(string)

Ekleme URL'sinin autoAuth=true değerini içerip içermediğini denetler.

function autoAuthInEmbedUrl(embedUrl: string): boolean

Parametreler

embedUrl

string

Döndürülenler

boolean

callbackify(() => Promise<void>)

bir async işlevi (veya Promisedöndüren bir işlev) alır ve hata öncelikli geri çağırma stilini izleyen bir işlev döndürür; örneğin, son bağımsız değişken olarak (err, value) => ... geri çağırma alır. Geri çağırmada ilk bağımsız değişken reddetme nedeni (veya null çözümlendiyse Promise) ve ikinci bağımsız değişken çözümlenen değer olacaktır.

import { callbackify } from 'node:util';

async function fn() {
  return 'hello world';
}
const callbackFunction = callbackify(fn);

callbackFunction((err, ret) => {
  if (err) throw err;
  console.log(ret);
});

Yazdırılacak:

hello world

Geri çağırma zaman uyumsuz olarak yürütülür ve sınırlı bir yığın izlemesine sahip olur. Geri çağırma oluşursa, işlem bir 'uncaughtException' olayı yayar ve işlenmediyse çıkar.

null bir geri çağırmanın ilk bağımsız değişkeni olarak özel bir anlamı olduğundan, sarmalanmış bir işlev hatalı bir değer içeren bir Promise nedeni olarak reddederse, değer Erroradlı alanda depolanan özgün değerle bir reason sarmalanır.

function fn() {
  return Promise.reject(null);
}
const callbackFunction = util.callbackify(fn);

callbackFunction((err, ret) => {
  // When the Promise was rejected with `null` it is wrapped with an Error and
  // the original value is stored in `reason`.
  err && Object.hasOwn(err, 'reason') && err.reason === null;  // true
});

function callbackify(fn: () => Promise<void>): (callback: (err: NodeJS.ErrnoException) => void) => void

Parametreler

fn

() => Promise<void>

async işlevi

Döndürülenler

(callback: (err: NodeJS.ErrnoException) => void) => void

geri çağırma stili işlevi

callbackify<T1, T2, T3, T4, T5, T6, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>) 

function callbackify<T1, T2, T3, T4, T5, T6, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void

Parametreler

fn

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<TResult>

Döndürülenler

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void

callbackify<T1, T2, T3, T4, T5, T6>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>) 

function callbackify<T1, T2, T3, T4, T5, T6>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: NodeJS.ErrnoException) => void) => void

Parametreler

fn

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6) => Promise<void>

Döndürülenler

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, arg6: T6, callback: (err: NodeJS.ErrnoException) => void) => void

callbackify<T1, T2, T3, T4, T5, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>) 

function callbackify<T1, T2, T3, T4, T5, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void

Parametreler

fn

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>

Döndürülenler

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void

callbackify<T1, T2, T3, T4, T5>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>) 

function callbackify<T1, T2, T3, T4, T5>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: NodeJS.ErrnoException) => void) => void

Parametreler

fn

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>

Döndürülenler

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: NodeJS.ErrnoException) => void) => void

callbackify<T1, T2, T3, T4, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>) 

function callbackify<T1, T2, T3, T4, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void

Parametreler

fn

(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>

Döndürülenler

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void

callbackify<T1, T2, T3, T4>((arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>) 

function callbackify<T1, T2, T3, T4>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException) => void) => void

Parametreler

fn

(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>

Döndürülenler

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: NodeJS.ErrnoException) => void) => void

callbackify<T1, T2, T3, TResult>((arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>) 

function callbackify<T1, T2, T3, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void

Parametreler

fn

(arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>

Döndürülenler

(arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void

callbackify<T1, T2, T3>((arg1: T1, arg2: T2, arg3: T3) => Promise<void>) 

function callbackify<T1, T2, T3>(fn: (arg1: T1, arg2: T2, arg3: T3) => Promise<void>): (arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException) => void) => void

Parametreler

fn

(arg1: T1, arg2: T2, arg3: T3) => Promise<void>

Döndürülenler

(arg1: T1, arg2: T2, arg3: T3, callback: (err: NodeJS.ErrnoException) => void) => void

callbackify<T1, T2, TResult>((arg1: T1, arg2: T2) => Promise<TResult>) 

function callbackify<T1, T2, TResult>(fn: (arg1: T1, arg2: T2) => Promise<TResult>): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void

Parametreler

fn

(arg1: T1, arg2: T2) => Promise<TResult>

Döndürülenler

(arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException | null, result: TResult) => void) => void

callbackify<T1, T2>((arg1: T1, arg2: T2) => Promise<void>) 

function callbackify<T1, T2>(fn: (arg1: T1, arg2: T2) => Promise<void>): (arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException) => void) => void

Parametreler

fn

(arg1: T1, arg2: T2) => Promise<void>

Döndürülenler

(arg1: T1, arg2: T2, callback: (err: NodeJS.ErrnoException) => void) => void

callbackify<T1, TResult>((arg1: T1) => Promise<TResult>) 

function callbackify<T1, TResult>(fn: (arg1: T1) => Promise<TResult>): (arg1: T1, callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void

Parametreler

fn

(arg1: T1) => Promise<TResult>

Döndürülenler

(arg1: T1, callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void

callbackify<T1>((arg1: T1) => Promise<void>) 

function callbackify<T1>(fn: (arg1: T1) => Promise<void>): (arg1: T1, callback: (err: NodeJS.ErrnoException) => void) => void

Parametreler

fn

(arg1: T1) => Promise<void>

Döndürülenler

(arg1: T1, callback: (err: NodeJS.ErrnoException) => void) => void

callbackify<TResult>(() => Promise<TResult>) 

function callbackify<TResult>(fn: () => Promise<TResult>): (callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void

Parametreler

fn

() => Promise<TResult>

Döndürülenler

(callback: (err: NodeJS.ErrnoException, result: TResult) => void) => void

createRandomString()

Rastgele 5 ile 6 karakterlik bir dize oluşturur.

function createRandomString(): string

Döndürülenler

string

debuglog(string, (fn: DebugLoggerFunction) => void)

util.debuglog() yöntemi, ortam değişkeninin varlığına stderr bağlı olarak hata ayıklama iletilerini koşullu olarak yazan bir işlev oluşturmak için NODE_DEBUG kullanılır. section adı bu ortam değişkeninin değeri içinde görünüyorsa, döndürülen işlev console.error()benzer şekilde çalışır. Değilse, döndürülen işlev bir no-opolur.

import { debuglog } from 'node:util';
const log = debuglog('foo');

log('hello from foo [%d]', 123);

Bu program ortamdaki NODE_DEBUG=foo ile çalıştırılırsa şuna benzer bir çıkış oluşturur:

FOO 3245: hello from foo [123]

burada 3245 işlem kimliğidir. Bu ortam değişkeni kümesiyle çalıştırılmazsa hiçbir şey yazdırmaz.

section joker karakteri de destekler:

import { debuglog } from 'node:util';
const log = debuglog('foo');

log('hi there, it\'s foo-bar [%d]', 2333);

ortamda NODE_DEBUG=foo* ile çalıştırılırsa şuna benzer bir çıkış oluşturur:

FOO-BAR 3257: hi there, it's foo-bar [2333]

Ortam değişkeninde section birden çok virgülle ayrılmış NODE_DEBUG ad belirtilebilir: NODE_DEBUG=fs,net,tls.

İsteğe bağlı callback bağımsız değişkeni, günlük işlevini başlatma veya gereksiz kaydırma içermeyen farklı bir işlevle değiştirmek için kullanılabilir.

import { debuglog } from 'node:util';
let log = debuglog('internals', (debug) => {
  // Replace with a logging function that optimizes out
  // testing if the section is enabled
  log = debug;
});

function debuglog(section: string, callback?: (fn: DebugLoggerFunction) => void): DebugLogger

Parametreler

section

string

uygulamanın debuglog işlevinin oluşturulduğu bölümünü tanımlayan dize.

callback

(fn: DebugLoggerFunction) => void

Daha iyileştirilmiş bir günlüğe kaydetme işlevi olan bir işlev bağımsız değişkeniyle günlük işlevi ilk kez çağrıldığında bir geri çağırma çağrılır.

Döndürülenler

DebugLogger

Günlük işlevi

deprecate<T>(T, string, string)

util.deprecate() yöntemi, fn (işlev veya sınıf olabilir) kullanım dışı olarak işaretlenecek şekilde sarmalar.

import { deprecate } from 'node:util';

export const obsoleteFunction = deprecate(() => {
  // Do something here.
}, 'obsoleteFunction() is deprecated. Use newShinyFunction() instead.');

çağrıldığında, util.deprecate()DeprecationWarning olayını kullanarak bir 'warning' yayacak bir işlev döndürür. Uyarı gönderilir ve döndürülen işlevin ilk çağrılışında stderr yazdırılır. Uyarı gönderildikten sonra sarmalanan işlev bir uyarı yaymadan çağrılır.

aynı isteğe bağlı codeutil.deprecate()için birden çok çağrıda sağlanırsa, uyarı bu codeiçin yalnızca bir kez gönderilir.

import { deprecate } from 'node:util';

const fn1 = deprecate(
  () => 'a value',
  'deprecation message',
  'DEP0001',
);
const fn2 = deprecate(
  () => 'a  different value',
  'other dep message',
  'DEP0001',
);
fn1(); // Emits a deprecation warning with code DEP0001
fn2(); // Does not emit a deprecation warning because it has the same code

veya komut satırı bayrakları kullanılırsa veya özelliği ilk kullanımdan kaldırma uyarısına önce olarak ayarlanırsa, yöntemi hiçbir şey yapmaz.

--trace-deprecation veya --trace-warnings komut satırı bayrakları ayarlanırsa veya process.traceDeprecation özelliği trueolarak ayarlanırsa, kullanım dışı bırakılan işlev ilk çağrılırken stderr için bir uyarı ve yığın izlemesi yazdırılır.

--throw-deprecation komut satırı bayrağı ayarlanırsa veya process.throwDeprecation özelliği trueolarak ayarlanırsa, kullanım dışı bırakılan işlev çağrıldığında bir özel durum oluşturulur.

--throw-deprecation komut satırı bayrağı ve process.throwDeprecation özelliği, --trace-deprecation ve process.traceDeprecation'den önceliklidir.

function deprecate<T>(fn: T, msg: string, code?: string): T

Parametreler

fn

T

Kullanım dışı bırakılan işlev.

msg

string

Kullanım dışı bırakılan işlev çağrıldığında görüntülenecek bir uyarı iletisi.

code

string

Kullanımdan kaldırma kodu. Kod listesi için list of deprecated APIs bakın.

Döndürülenler

T

Bir uyarı yaymak için sarmalanmış kullanım dışı işlevi.

diff(string | (readonly string[]), string | (readonly string[]))

util.diff() iki dize veya dizi değerini karşılaştırır ve bir fark girdileri dizisi döndürür. Myers fark algoritmasını kullanarak, onaylama hata iletileri tarafından dahili olarak kullanılan aynı algoritma olan en düşük farkları hesaplar.

Değerler eşitse boş bir dizi döndürülür.

const { diff } = require('node:util');

// Comparing strings
const actualString = '12345678';
const expectedString = '12!!5!7!';
console.log(diff(actualString, expectedString));
// [
//   [0, '1'],
//   [0, '2'],
//   [1, '3'],
//   [1, '4'],
//   [-1, '!'],
//   [-1, '!'],
//   [0, '5'],
//   [1, '6'],
//   [-1, '!'],
//   [0, '7'],
//   [1, '8'],
//   [-1, '!'],
// ]
// Comparing arrays
const actualArray = ['1', '2', '3'];
const expectedArray = ['1', '3', '4'];
console.log(diff(actualArray, expectedArray));
// [
//   [0, '1'],
//   [1, '2'],
//   [0, '3'],
//   [-1, '4'],
// ]
// Equal values return empty array
console.log(diff('same', 'same'));
// []

function diff(actual: string | (readonly string[]), expected: string | (readonly string[])): DiffEntry[]

Parametreler

actual

string | (readonly string[])

Karşılaştıracak ilk değer

expected

string | (readonly string[])

Karşılaştıracak ikinci değer

Döndürülenler

DiffEntry[]

Fark girdileri dizisi. Her girdi, iki öğe içeren bir dizidir:

  • Dizin 0: number İşlem kodu: -1 silme için, 0 no-op/unchanged için, 1 ekleme için
  • Dizin 1: string İşlemle ilişkili değer

find<T>((x: T) => boolean, T[])

Belirtilen koşulla eşleşen bir dizideki ilk değeri bulur.

function find<T>(predicate: (x: T) => boolean, xs: T[]): T

Parametreler

predicate

(x: T) => boolean

xs

T[]

Döndürülenler

T

findIndex<T>((x: T) => boolean, T[])

Belirtilen koşulla eşleşen bir dizideki ilk değerin dizinini bulur.

function findIndex<T>(predicate: (x: T) => boolean, xs: T[]): number

Parametreler

predicate

(x: T) => boolean

xs

T[]

Döndürülenler

number

format(any, any[])

util.format() yöntemi, ilk bağımsız değişkeni sıfır veya daha fazla biçim tanımlayıcısı içerebilen printfbiçim dizesi olarak biçimlendirilmiş bir dize döndürür. Her tanımlayıcı, karşılık gelen bağımsız değişkenden dönüştürülen değerle değiştirilir. Desteklenen tanımlayıcılar şunlardır:

Tanımlayıcının karşılık gelen bağımsız değişkeni yoksa, değiştirilmez:

util.format('%s:%s', 'foo');
// Returns: 'foo:%s'

Biçim dizesinin parçası olmayan değerler, türleri util.inspect()değilse string kullanılarak biçimlendirilir.

util.format() yöntemine tanımlayıcı sayısından daha fazla bağımsız değişken geçirilirse, fazladan bağımsız değişkenler döndürülen dizeye boşluklarla ayrılmış olarak birleştirilir:

util.format('%s:%s', 'foo', 'bar', 'baz');
// Returns: 'foo:bar baz'

İlk bağımsız değişken geçerli bir biçim tanımlayıcısı içermiyorsa, util.format() boşluklarla ayrılmış tüm bağımsız değişkenlerin birleşimi olan bir dize döndürür:

util.format(1, 2, 3);
// Returns: '1 2 3'

util.format()yalnızca bir bağımsız değişken geçirilirse, herhangi bir biçimlendirme olmadan döndürülür:

util.format('%% %s');
// Returns: '%% %s'

util.format(), hata ayıklama aracı olarak amaçlanan zaman uyumlu bir yöntemdir. Bazı giriş değerleri, olay döngüsünü engelleyebilecek önemli bir performans yüküne sahip olabilir. Bu işlevi dikkatli kullanın ve hiçbir zaman sık erişimli kod yolunda kullanmayın.

function format(format?: any, param: any[]): string

Parametreler

format

any

printfbenzeri bir biçim dizesi.

param

any[]

Döndürülenler

string

formatWithOptions(InspectOptions, any, any[])

Bu işlev,biçimiyle aynıdır, ancakincelemek geçirilecek seçenekleri belirten bir bağımsız değişkeni alır.

util.formatWithOptions({ colors: true }, 'See object %O', { foo: 42 });
// Returns 'See object { foo: 42 }', where `42` is colored as a number
// when printed to a terminal.

function formatWithOptions(inspectOptions: InspectOptions, format?: any, param: any[]): string

Parametreler

inspectOptions
InspectOptions
format

any

param

any[]

Döndürülenler

string

generateUUID()

20 karakterlik uuid oluşturur.

function generateUUID(): string

Döndürülenler

string

getCallSites(GetCallSitesOptions) 

function getCallSites(options: GetCallSitesOptions): CallSiteObject[]

Parametreler

options

GetCallSitesOptions

Döndürülenler

CallSiteObject[]

getCallSites(number, GetCallSitesOptions)

Çağıran işlevinin yığınını içeren bir çağrı sitesi nesneleri dizisi döndürür.

import { getCallSites } from 'node:util';

function exampleFunction() {
  const callSites = getCallSites();

  console.log('Call Sites:');
  callSites.forEach((callSite, index) => {
    console.log(`CallSite ${index + 1}:`);
    console.log(`Function Name: ${callSite.functionName}`);
    console.log(`Script Name: ${callSite.scriptName}`);
    console.log(`Line Number: ${callSite.lineNumber}`);
    console.log(`Column Number: ${callSite.column}`);
  });
  // CallSite 1:
  // Function Name: exampleFunction
  // Script Name: /home/example.js
  // Line Number: 5
  // Column Number: 26

  // CallSite 2:
  // Function Name: anotherFunction
  // Script Name: /home/example.js
  // Line Number: 22
  // Column Number: 3

  // ...
}

// A function to simulate another stack layer
function anotherFunction() {
  exampleFunction();
}

anotherFunction();

sourceMap seçeneğini trueolarak ayarlayarak özgün konumları yeniden yapılandırmak mümkündür. Kaynak harita kullanılamıyorsa, özgün konum geçerli konumla aynı olur. örneğin --enable-source-mapskullanıldığında --experimental-transform-types bayrağı etkinleştirildiğinde sourceMap varsayılan olarak true olur.

import { getCallSites } from 'node:util';

interface Foo {
  foo: string;
}

const callSites = getCallSites({ sourceMap: true });

// With sourceMap:
// Function Name: ''
// Script Name: example.js
// Line Number: 7
// Column Number: 26

// Without sourceMap:
// Function Name: ''
// Script Name: example.js
// Line Number: 2
// Column Number: 26

function getCallSites(frameCount?: number, options?: GetCallSitesOptions): CallSiteObject[]

Parametreler

frameCount

number

Çağrı sitesi nesneleri olarak yakalanacak kare sayısı. Varsayılan:10. İzin verilebilen aralık 1 ile 200 arasındadır.

options

GetCallSitesOptions

Döndürülenler

CallSiteObject[]

Site nesnelerini çağırma dizisi

getRandomValue()

Rastgele sayı verir

function getRandomValue(): number

Döndürülenler

number

getSystemErrorMap()

Node.js API'sinden kullanılabilen tüm sistem hata kodlarının haritasını döndürür. Hata kodları ve hata adları arasındaki eşleme platforma bağlıdır. Yaygın hataların adları için bkz. Common System Errors.

fs.access('file/that/does/not/exist', (err) => {
  const errorMap = util.getSystemErrorMap();
  const name = errorMap.get(err.errno);
  console.error(name);  // ENOENT
});

function getSystemErrorMap(): Map<number, [string, string]>

Döndürülenler

Map<number, [string, string]>

getSystemErrorMessage(number)

Node.js API'sinden gelen sayısal bir hata kodu için dize iletisini döndürür. Hata kodları ve dize iletileri arasındaki eşleme platforma bağlıdır.

fs.access('file/that/does/not/exist', (err) => {
  const message = util.getSystemErrorMessage(err.errno);
  console.error(message);  // no such file or directory
});

function getSystemErrorMessage(err: number): string

Parametreler

err

number

Döndürülenler

string

getSystemErrorName(number)

Node.js API'sinden gelen sayısal bir hata kodunun dize adını döndürür. Hata kodları ve hata adları arasındaki eşleme platforma bağlıdır. Yaygın hataların adları için bkz. Common System Errors.

fs.access('file/that/does/not/exist', (err) => {
  const name = util.getSystemErrorName(err.errno);
  console.error(name);  // ENOENT
});

function getSystemErrorName(err: number): string

Parametreler

err

number

Döndürülenler

string

getTimeDiffInMilliseconds(Date, Date)

İki tarih arasındaki zaman aralığını milisaniye cinsinden verir

function getTimeDiffInMilliseconds(start: Date, end: Date): number

Parametreler

start

Date

end

Date

Döndürülenler

number

inherits(unknown, unknown)

util.inherits() kullanımı önerilmez. Dil düzeyinde devralma desteği almak için lütfen ES6 class ve extends anahtar sözcüklerini kullanın. Ayrıca, iki stilin uyumsuz olduğunu unutmayın.

Prototip yöntemlerini bir oluşturucudan diğerine devralın. constructor prototipi, superConstructor'den oluşturulan yeni bir nesneye ayarlanır.

Bu, temel olarak üzerine Object.setPrototypeOf(constructor.prototype, superConstructor.prototype)bazı giriş doğrulamaları ekler. Ek bir kolaylık olarak, superConstructorconstructor.super_ özelliği aracılığıyla erişilebilir olacaktır.

const util = require('node:util');
const EventEmitter = require('node:events');

function MyStream() {
  EventEmitter.call(this);
}

util.inherits(MyStream, EventEmitter);

MyStream.prototype.write = function(data) {
  this.emit('data', data);
};

const stream = new MyStream();

console.log(stream instanceof EventEmitter); // true
console.log(MyStream.super_ === EventEmitter); // true

stream.on('data', (data) => {
  console.log(`Received data: "${data}"`);
});
stream.write('It works!'); // Received data: "It works!"

class ve extendskullanan ES6 örneği:

import EventEmitter from 'node:events';

class MyStream extends EventEmitter {
  write(data) {
    this.emit('data', data);
  }
}

const stream = new MyStream();

stream.on('data', (data) => {
  console.log(`Received data: "${data}"`);
});
stream.write('With ES6');

function inherits(constructor: unknown, superConstructor: unknown)

Parametreler

constructor

unknown

superConstructor

unknown

inspect(any, boolean, null | number, boolean)

util.inspect() yöntemi, hata ayıklamaya yönelik object dize gösterimini döndürür. util.inspect çıkışı herhangi bir zamanda değişebilir ve program aracılığıyla bağımlı olmamalıdır. Sonucu değiştiren ek options geçirilebilir. util.inspect() , denetlenen bir değer için tanımlanabilir bir etiket oluşturmak için oluşturucunun adını ve/veya Symbol.toStringTag özelliğini kullanır.

class Foo {
  get [Symbol.toStringTag]() {
    return 'bar';
  }
}

class Bar {}

const baz = Object.create(null, { [Symbol.toStringTag]: { value: 'foo' } });

util.inspect(new Foo()); // 'Foo [bar] {}'
util.inspect(new Bar()); // 'Bar {}'
util.inspect(baz);       // '[foo] {}'

Döngüsel başvurular, bir başvuru dizini kullanarak bağlayıcılarına işaret eder:

import { inspect } from 'node:util';

const obj = {};
obj.a = [obj];
obj.b = {};
obj.b.inner = obj.b;
obj.b.obj = obj;

console.log(inspect(obj));
// <ref *1> {
//   a: [ [Circular *1] ],
//   b: <ref *2> { inner: [Circular *2], obj: [Circular *1] }
// }

Aşağıdaki örnek, util nesnesinin tüm özelliklerini inceler:

import util from 'node:util';

console.log(util.inspect(util, { showHidden: true, depth: null }));

Aşağıdaki örnekte compact seçeneğinin etkisi vurgulanır:

import { inspect } from 'node:util';

const o = {
  a: [1, 2, [[
    'Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit, sed do ' +
      'eiusmod \ntempor incididunt ut labore et dolore magna aliqua.',
    'test',
    'foo']], 4],
  b: new Map([['za', 1], ['zb', 'test']]),
};
console.log(inspect(o, { compact: true, depth: 5, breakLength: 80 }));

// { a:
//   [ 1,
//     2,
//     [ [ 'Lorem ipsum dolor sit amet,\nconsectetur [...]', // A long line
//           'test',
//           'foo' ] ],
//     4 ],
//   b: Map(2) { 'za' => 1, 'zb' => 'test' } }

// Setting `compact` to false or an integer creates more reader friendly output.
console.log(inspect(o, { compact: false, depth: 5, breakLength: 80 }));

// {
//   a: [
//     1,
//     2,
//     [
//       [
//         'Lorem ipsum dolor sit amet,\n' +
//           'consectetur adipiscing elit, sed do eiusmod \n' +
//           'tempor incididunt ut labore et dolore magna aliqua.',
//         'test',
//         'foo'
//       ]
//     ],
//     4
//   ],
//   b: Map(2) {
//     'za' => 1,
//     'zb' => 'test'
//   }
// }

// Setting `breakLength` to e.g. 150 will print the "Lorem ipsum" text in a
// single line.

showHidden seçeneği, WeakMap ve WeakSet girdilerinin denetlenmesini sağlar. maxArrayLength'den daha fazla girdi varsa, hangi girişlerin görüntüleneceğinin garantisi yoktur. Başka bir deyişle aynı WeakSet girdilerinin iki kez alınması farklı çıkışlara neden olabilir. Ayrıca, hiçbir güçlü başvurusu olmayan girdiler herhangi bir zamanda çöp olarak toplanabilir.

import { inspect } from 'node:util';

const obj = { a: 1 };
const obj2 = { b: 2 };
const weakSet = new WeakSet([obj, obj2]);

console.log(inspect(weakSet, { showHidden: true }));
// WeakSet { { a: 1 }, { b: 2 } }

sorted seçeneği, nesnenin özellik ekleme sırasının util.inspect()sonucunu etkilememesini sağlar.

import { inspect } from 'node:util';
import assert from 'node:assert';

const o1 = {
  b: [2, 3, 1],
  a: '`a` comes before `b`',
  c: new Set([2, 3, 1]),
};
console.log(inspect(o1, { sorted: true }));
// { a: '`a` comes before `b`', b: [ 2, 3, 1 ], c: Set(3) { 1, 2, 3 } }
console.log(inspect(o1, { sorted: (a, b) => b.localeCompare(a) }));
// { c: Set(3) { 3, 2, 1 }, b: [ 2, 3, 1 ], a: '`a` comes before `b`' }

const o2 = {
  c: new Set([2, 1, 3]),
  a: '`a` comes before `b`',
  b: [2, 3, 1],
};
assert.strict.equal(
  inspect(o1, { sorted: true }),
  inspect(o2, { sorted: true }),
);

numericSeparator seçeneği, tüm sayılara her üç basamağı bir alt çizgi ekler.

import { inspect } from 'node:util';

const thousand = 1000;
const million = 1000000;
const bigNumber = 123456789n;
const bigDecimal = 1234.12345;

console.log(inspect(thousand, { numericSeparator: true }));
// 1_000
console.log(inspect(million, { numericSeparator: true }));
// 1_000_000
console.log(inspect(bigNumber, { numericSeparator: true }));
// 123_456_789n
console.log(inspect(bigDecimal, { numericSeparator: true }));
// 1_234.123_45

util.inspect(), hata ayıklamaya yönelik zaman uyumlu bir yöntemdir. Maksimum çıkış uzunluğu yaklaşık 128 MiB'dir. Daha uzun çıkışla sonuçlanacak girişler kesilir.

function inspect(object: any, showHidden?: boolean, depth?: null | number, color?: boolean): string

Parametreler

object

any

Herhangi bir JavaScript ilkel veya Object.

showHidden

boolean

depth

null | number

color

boolean

Döndürülenler

string

objectgösterimi.

inspect(any, InspectOptions) 

function inspect(object: any, options?: InspectOptions): string

Parametreler

object

any

options
InspectOptions

Döndürülenler

string

isArray(unknown)

Uyarı

Bu API artık kullanım dışıdır.

Since v4.0.0 - Use isArray instead.

Diğer ad için Array.isArray().

Verilen true bir objectise Array döndürür. Aksi takdirde döndürür false.

import util from 'node:util';

util.isArray([]);
// Returns: true
util.isArray(new Array());
// Returns: true
util.isArray({});
// Returns: false

function isArray(object: unknown): object

Parametreler

object

unknown

Döndürülenler

object

isCreate(string)

Ekleme türünün oluşturma için olup olmadığını denetler

function isCreate(embedType: string): boolean

Parametreler

embedType

string

Döndürülenler

boolean

isDeepStrictEqual(unknown, unknown, IsDeepStrictEqualOptions)

true ile val1arasında derin katı eşitlik varsa val2 döndürür. Aksi takdirde döndürür false.

Derin katı eşitlik hakkında daha fazla bilgi için bkz. assert.deepStrictEqual().

function isDeepStrictEqual(val1: unknown, val2: unknown, options?: IsDeepStrictEqualOptions): boolean

Parametreler

val1

unknown

val2

unknown

options
IsDeepStrictEqualOptions

Döndürülenler

boolean

isRDLEmbed(string)

Ekleme URL'sinin RDL raporu için olup olmadığını denetler.

function isRDLEmbed(embedUrl: string): boolean

Parametreler

embedUrl

string

Döndürülenler

boolean

isSavedInternal(HttpPostMessage, string, Window)

Raporun kaydedilip kaydedilmediğini denetler.

function isSavedInternal(hpm: HttpPostMessage, uid: string, contentWindow: Window): Promise<boolean>

Parametreler

hpm

HttpPostMessage

uid

string

contentWindow

Window

Döndürülenler

Promise<boolean>

parseArgs<T>(T)

Komut satırı bağımsız değişken ayrıştırma için doğrudan process.argv etkileşime kıyasla daha yüksek düzeyde bir API sağlar. Beklenen bağımsız değişkenler için bir belirtim alır ve ayrıştırılmış seçenekler ve konumsallar ile yapılandırılmış bir nesne döndürür.

import { parseArgs } from 'node:util';
const args = ['-f', '--bar', 'b'];
const options = {
  foo: {
    type: 'boolean',
    short: 'f',
  },
  bar: {
    type: 'string',
  },
};
const {
  values,
  positionals,
} = parseArgs({ args, options });
console.log(values, positionals);
// Prints: [Object: null prototype] { foo: true, bar: 'b' } []

function parseArgs<T>(config?: T): ParsedResults<T>

Parametreler

config

T

Ayrıştırma için bağımsız değişkenler sağlamak ve ayrıştırıcıyı yapılandırmak için kullanılır. config aşağıdaki özellikleri destekler:

Döndürülenler

ParsedResults<T>

Ayrıştırılan komut satırı bağımsız değişkenleri:

parseEnv(string)

Kararlılık: 1.1 - Etkin geliştirme Örnek bir .env dosyası verilmiştir:

import { parseEnv } from 'node:util';

parseEnv('HELLO=world\nHELLO=oh my\n');
// Returns: { HELLO: 'oh my' }

function parseEnv(content: string): NodeJS.Dict<string>

Parametreler

content

string

.env dosyasının ham içeriği.

Döndürülenler

NodeJS.Dict<string>

promisify((callback: (err?: any) => void) => void) 

function promisify(fn: (callback: (err?: any) => void) => void): () => Promise<void>

Parametreler

fn

(callback: (err?: any) => void) => void

Döndürülenler

() => Promise<void>

promisify(Function) 

function promisify(fn: Function): Function

Parametreler

fn

Function

Döndürülenler

Function

promisify<T1, T2, T3, T4, T5, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void) 

function promisify<T1, T2, T3, T4, T5, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>

Parametreler

fn

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err: any, result: TResult) => void) => void

Döndürülenler

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<TResult>

promisify<T1, T2, T3, T4, T5>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void) 

function promisify<T1, T2, T3, T4, T5>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>

Parametreler

fn

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, callback: (err?: any) => void) => void

Döndürülenler

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5) => Promise<void>

promisify<T1, T2, T3, T4, TResult>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void) 

function promisify<T1, T2, T3, T4, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>

Parametreler

fn

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err: any, result: TResult) => void) => void

Döndürülenler

(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<TResult>

promisify<T1, T2, T3, T4>((arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void) 

function promisify<T1, T2, T3, T4>(fn: (arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>

Parametreler

fn

(arg1: T1, arg2: T2, arg3: T3, arg4: T4, callback: (err?: any) => void) => void

Döndürülenler

(arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Promise<void>

promisify<T1, T2, T3, TResult>((arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void) 

function promisify<T1, T2, T3, TResult>(fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>

Parametreler

fn

(arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: TResult) => void) => void

Döndürülenler

(arg1: T1, arg2: T2, arg3: T3) => Promise<TResult>

promisify<T1, T2, T3>((arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void) 

function promisify<T1, T2, T3>(fn: (arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2, arg3: T3) => Promise<void>

Parametreler

fn

(arg1: T1, arg2: T2, arg3: T3, callback: (err?: any) => void) => void

Döndürülenler

(arg1: T1, arg2: T2, arg3: T3) => Promise<void>

promisify<T1, T2, TResult>((arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void) 

function promisify<T1, T2, TResult>(fn: (arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void): (arg1: T1, arg2: T2) => Promise<TResult>

Parametreler

fn

(arg1: T1, arg2: T2, callback: (err: any, result: TResult) => void) => void

Döndürülenler

(arg1: T1, arg2: T2) => Promise<TResult>

promisify<T1, T2>((arg1: T1, arg2: T2, callback: (err?: any) => void) => void) 

function promisify<T1, T2>(fn: (arg1: T1, arg2: T2, callback: (err?: any) => void) => void): (arg1: T1, arg2: T2) => Promise<void>

Parametreler

fn

(arg1: T1, arg2: T2, callback: (err?: any) => void) => void

Döndürülenler

(arg1: T1, arg2: T2) => Promise<void>

promisify<T1, TResult>((arg1: T1, callback: (err: any, result: TResult) => void) => void) 

function promisify<T1, TResult>(fn: (arg1: T1, callback: (err: any, result: TResult) => void) => void): (arg1: T1) => Promise<TResult>

Parametreler

fn

(arg1: T1, callback: (err: any, result: TResult) => void) => void

Döndürülenler

(arg1: T1) => Promise<TResult>

promisify<T1>((arg1: T1, callback: (err?: any) => void) => void) 

function promisify<T1>(fn: (arg1: T1, callback: (err?: any) => void) => void): (arg1: T1) => Promise<void>

Parametreler

fn

(arg1: T1, callback: (err?: any) => void) => void

Döndürülenler

(arg1: T1) => Promise<void>

promisify<TCustom>(CustomPromisify<TCustom>)

Hata öncelikli yaygın geri çağırma stilini izleyen bir işlev alır; örneğin, son bağımsız değişken olarak (err, value) => ... bir geri çağırma alır ve promises döndüren bir sürüm döndürür.

import { promisify } from 'node:util';
import { stat } from 'node:fs';

const promisifiedStat = promisify(stat);
promisifiedStat('.').then((stats) => {
  // Do something with `stats`
}).catch((error) => {
  // Handle the error.
});

Veya eşdeğer olarak async functionkullanarak:

import { promisify } from 'node:util';
import { stat } from 'node:fs';

const promisifiedStat = promisify(stat);

async function callStat() {
  const stats = await promisifiedStat('.');
  console.log(`This directory is owned by ${stats.uid}`);
}

callStat();

Bir özellik varsa original[util.promisify.custom] değerini promisify döndürür, bkz . Özel promisified functions.

promisify(), original her durumda son bağımsız değişkeni olarak geri çağırmayı alan bir işlev olduğunu varsayar. original bir işlev değilse promisify() bir hata oluşturur. original bir işlevse ancak son bağımsız değişkeni hata öncelikli bir geri çağırma değilse, yine de son bağımsız değişkeni olarak hata öncelikli bir geri çağırma geçirilir.

Sınıf yöntemlerinde veya promisify() kullanan diğer yöntemlerde this kullanılması, özel olarak işlenmediği sürece beklendiği gibi çalışmayabilir:

import { promisify } from 'node:util';

class Foo {
  constructor() {
    this.a = 42;
  }

  bar(callback) {
    callback(null, this.a);
  }
}

const foo = new Foo();

const naiveBar = promisify(foo.bar);
// TypeError: Cannot read properties of undefined (reading 'a')
// naiveBar().then(a => console.log(a));

naiveBar.call(foo).then((a) => console.log(a)); // '42'

const bindBar = naiveBar.bind(foo);
bindBar().then((a) => console.log(a)); // '42'

function promisify<TCustom>(fn: CustomPromisify<TCustom>): TCustom

Parametreler

fn

CustomPromisify<TCustom>

Döndürülenler

TCustom

promisify<TResult>((callback: (err: any, result: TResult) => void) => void) 

function promisify<TResult>(fn: (callback: (err: any, result: TResult) => void) => void): () => Promise<TResult>

Parametreler

fn

(callback: (err: any, result: TResult) => void) => void

Döndürülenler

() => Promise<TResult>

raiseCustomEvent(HTMLElement, string, any)

Belirtilen HTML öğesinde olay verileriyle özel bir olay oluşturur.

function raiseCustomEvent(element: HTMLElement, eventName: string, eventData: any)

Parametreler

element

HTMLElement

eventName

string

eventData

any

remove<T>((x: T) => boolean, T[]) 

function remove<T>(predicate: (x: T) => boolean, xs: T[])

Parametreler

predicate

(x: T) => boolean

xs

T[]

setTraceSigInt(boolean)

üzerinde SIGINTyığın izlemesi yazdırmayı etkinleştirin veya devre dışı bırakın. API yalnızca ana iş parçacığında kullanılabilir.

function setTraceSigInt(enable: boolean)

Parametreler

enable

boolean

stripVTControlCharacters(string)

ANSI kaçış kodları kaldırılmış str döndürür.

console.log(util.stripVTControlCharacters('\u001B[4mvalue\u001B[0m'));
// Prints "value"

function stripVTControlCharacters(str: string): string

Parametreler

str

string

Döndürülenler

string

styleText(ForegroundColors | BackgroundColors | Modifiers | (ForegroundColors | BackgroundColors | Modifiers)[], string, StyleTextOptions)

Bu işlev, terminalde yazdırma için geçirilen değerini dikkate format alarak biçimlendirilmiş bir metin döndürür. Terminalin özelliklerinin farkındadır ve aracılığıyla NO_COLORNODE_DISABLE_COLORS ayarlanan yapılandırmaya ve FORCE_COLOR ortam değişkenlerine göre hareket eder.

import { styleText } from 'node:util';
import { stderr } from 'node:process';

const successMessage = styleText('green', 'Success!');
console.log(successMessage);

const errorMessage = styleText(
  'red',
  'Error! Error!',
  // Validate if process.stderr has TTY
  { stream: stderr },
);
console.error(errorMessage);

util.inspect.colors, italicve underline gibi metin biçimleri de sağlar ve her ikisini de birleştirebilirsiniz:

console.log(
  util.styleText(['underline', 'italic'], 'My italic underlined message'),
);

Bir biçim dizisi geçirilirken, uygulanan biçimin sırası soldan sağa doğru olur, bu nedenle aşağıdaki stil öncekinin üzerine yazabilir.

console.log(
  util.styleText(['red', 'green'], 'text'), // green
);

Özel biçim değeri none metne ek stil uygulamaz.

Biçimlerin tam listesideğiştiricilerinde bulunabilir.

function styleText(format: ForegroundColors | BackgroundColors | Modifiers | (ForegroundColors | BackgroundColors | Modifiers)[], text: string, options?: StyleTextOptions): string

Parametreler

format

ForegroundColors | BackgroundColors | Modifiers | (ForegroundColors | BackgroundColors | Modifiers)[]

bir metin biçimi veya util.inspect.colorsiçinde tanımlanan metin biçimleri dizisi.

text

string

Biçimlendirilecek metin.

options
StyleTextOptions

Döndürülenler

string

toUSVString(string)

Herhangi bir vekil kod noktası (veya eşdeğeri, eşleşmeyen vekil kod birimleri) Unicode "değiştirme karakteri" U+FFFD ile değiştirdikten sonra string döndürür.

function toUSVString(string: string): string

Parametreler

string

string

Döndürülenler

string

transferableAbortController()

AbortController aktarılabilir olarak işaretlenmiş ve AbortSignal veya structuredClone()ile kullanılabilen bir postMessage() örneği oluşturur ve döndürür.

function transferableAbortController(): AbortController

Döndürülenler

AbortController

Aktarılabilir AbortController

transferableAbortSignal(AbortSignal)

Verilen AbortSignal aktarılabilir olarak işaretler, böylecestructuredClone() ve postMessage()ile kullanılabilir.

const signal = transferableAbortSignal(AbortSignal.timeout(100));
const channel = new MessageChannel();
channel.port2.postMessage(signal, [signal]);

function transferableAbortSignal(signal: AbortSignal): AbortSignal

Parametreler

signal

AbortSignal

The AbortSignal

Döndürülenler

AbortSignal

Aynı AbortSignal