Node.js util moduli: parseArgs, styleText, inspect, promisify va debuglog

Qisqacha: Bu modul — har kuni kerak bo'ladigan kichik vositalar qutisi. Undagi parseArgs terminal argumentlarini (--sana 2026-10-18 -f csv) kutubxonasiz o'qiydi. Noma'lum bayroqda u xato beradi. Rang uchun — styleText: quvurda (| more) va NO_COLOR da u rangni o'zi o'chiradi. Obyektni o'qiladigan matnga inspect aylantiradi, shablon satrni — format. Callback funksiyani Promise'ga promisify o'giradi. Faqat NODE_DEBUG=nom bo'lganda ishlaydigan logni debuglog beradi, eskirgan funksiya haqida ogohlantirishni — deprecate.

Bu darsda

• parseArgs bilan valyuta ga haqiqiy bayroqlar qo'shasiz: qisqa (-f) va uzun (--format), sukut qiymat, xato.
• styleText bilan rang berasiz va rang qachon o'chishini o'lchov bilan bilasiz.
• inspect, format, isDeepStrictEqual, util.types ni to'g'ri joyda ishlatasiz.
• promisify, deprecate, debuglog nima uchun kerakligini tushunasiz.

Oldin bilishingiz kerak: process: argv, env, exit kodlari, path va os, Promise yordamchilari va promisify, Callbacklar.

1. Nega bu kerak?

Hozir valyuta argumentlarni qo'lda o'qiydi: process.argv[2] — buyruq, qolgani — valyuta kodlari (process darsi). Endi foydalanuvchi ko'proq narsa xohlaydi:

• valyuta kurs USD --sana 2026-10-01 — o'tgan kungi kurs;
• valyuta kurs USD -f csv — Excel uchun CSV;
• valyuta --version — qaysi versiya o'rnatilgan.

Qo'lda yozilgan argument o'qish tez murakkablashadi: --sana=2026-10-01 va --sana 2026-10-01 ikkalasi ham ishlashi kerak, -f va --format bir narsa, --yoq degan noma'lum bayroqqa jim qolmaslik kerak. Bunday kodni har CLI muallifi qaytadan yozardi — shuning uchun Node 18.3 dan util.parseArgs o'rnatilgan (Node 20 dan barqaror).

Shu darsda util ning boshqa vositalarini ham ko'ramiz. Ular alohida kichik, lekin hammasi CLI va serverda har kuni kerak: rang, chiroyli log, eskirgan funksiyani belgilash.

O'xshatish: usta qutisi. Bolg'a va arra (fs, http) — katta asboblar. Qutining burchagida esa kichik narsalar: ruletka, qalam, ruxsat skotch. Ularsiz ham ishlasa bo'ladi, lekin har safar qiynalasiz.

2. parseArgs: terminal argumentlari

2.1 Birinchi misol

parseArgs ga ikki narsa beriladi: argumentlar massivi (args) va kutilgan bayroqlar tavsifi (options). Odatda args — process.argv.slice(2). Misolda uni qo'lda beramiz, natija har safar bir xil bo'lsin:

import { parseArgs } from "node:util";

const { values, positionals } = parseArgs({
  args: ["kurs", "USD", "EUR", "--sana", "2026-10-18", "-f", "csv"],
  options: {
    sana: { type: "string", short: "s" },
    format: { type: "string", short: "f", default: "jadval" },
    offline: { type: "boolean", default: false },
  },
  allowPositionals: true,
});
console.log(values);
console.log(positionals);

Konsolda:

[Object: null prototype] {
  sana: '2026-10-18',
  format: 'csv',
  offline: false
}
[ 'kurs', 'USD', 'EUR' ]

• values — bayroqlar qiymatlari. -f (qisqa) format ga yozildi. offline berilmadi — sukut false.
• positionals — bayroqqa tegishli bo'lmagan argumentlar, tartibda: buyruq va valyuta kodlari.
• [Object: null prototype] — values prototipsiz obyekt (Object.create(null)). Buning sababi xavfsizlik: --__proto__ kabi bayroq obyektni buzolmaydi. Ishlatishda oddiy obyektdek.

Argument qayerga tushadi — rasmda. Chapdan o'ngga: terminal satri, parseArgs, ikki natija yoki xato:

flowchart LR
  A["valyuta kurs USD -f csv"] --> B["process.argv.slice(2)"]
  B --> C{"parseArgs"}
  C -->|"-f csv"| D["values: format = csv"]
  C -->|"kurs USD"| E["positionals"]
  C -->|"--yoq"| F["xato → exit 2"]

2.2 Bayroq turlari va opsiyalar

parseArgs ning o'z opsiyalari:

2.3 Xatolar

strict: true da noma'lum bayroq — darhol xato. Bu yaxshi: foydalanuvchi --sanaa deb xato yozsa, dastur indamay sukut sanani ishlatmaydi.

import { parseArgs } from "node:util";

const options = { sana: { type: "string" } };
for (const args of [["kurs", "--yoq"], ["--sana"]]) {
  try {
    parseArgs({ args, options, allowPositionals: true });
  } catch (xato) {
    console.log(xato.code);
  }
}

Konsolda:

ERR_PARSE_ARGS_UNKNOWN_OPTION
ERR_PARSE_ARGS_INVALID_OPTION_VALUE

Xabar matnlari (biz ishga tushirdik, Node 24.21.0):

Unknown option '--yoq'. To specify a positional argument starting with a '-', place it at the end of the command after '--', as in '-- "--yoq"
Option '--sana <value>' argument missing

Birinchisi: "noma'lum bayroq --yoq. Agar - bilan boshlanadigan oddiy argument bermoqchi bo'lsangiz, uni buyruq oxiriga -- dan keyin qo'ying". -- — "bundan keyin bayroq yo'q" degan Unix odati. Ikkinchisi: "--sana ga qiymat berilmadi".

Xabar inglizcha va uzun. Kanon uni tarjima qilmadi — parseArgs ning o'z matni foydalanuvchiga to'g'ridan chiqadi, ostida esa o'zbekcha yordam matni. Yaxshilash yo'li — xato.code ga qarab o'z xabaringizni yozish (2-mashq).

Tekshirib ko'ring: parseArgs ga ["--offline=yoq"] berilsa, offline — boolean bo'lsa nima bo'ladi?

3. styleText: rang va uning chegarasi

3.1 Terminalda rang qanday paydo bo'ladi

Terminal rangni maxsus belgilar ketma-ketligidan biladi — ANSI escape kodlari. Matn oldiga ESC[32m qo'yilsa — yashil, ESC[39m — oddiy rangga qaytish. util.styleText bu kodlarni o'zi qo'yadi:

import { styleText } from "node:util";

const opsiya = { validateStream: false };
const rangli = styleText("green", "-62.36", opsiya);
console.log(JSON.stringify(rangli));
console.log(rangli.length);

Konsolda:

"\u001b[32m-62.36\u001b[39m"
16

6 belgili -62.36 16 belgiga aylandi: 5 belgi oldida, 5 belgi oxirida. Terminal ularni chizmaydi, faqat rangni o'zgartiradi. Ranglar nomlari: red, green, yellow, blue, bold, dim, underline va boshqalar. Bir nechtasini massivda berish mumkin: styleText(["bold", "red"], "Xato").

3.2 Qachon rang kerak emas

Rang odam uchun. Lekin valyuta kurs USD > kurs.txt yoki valyuta kurs | grep USD — natija faylga yoki boshqa dasturga ketadi. U yerda \u001b[32m axlat bo'lib qoladi. Shuning uchun styleText sukut bo'yicha (validateStream: true) oqimni tekshiradi:

• oqim TTY (haqiqiy terminal) emas bo'lsa — rang yo'q;
• NO_COLOR muhit o'zgaruvchisi bor bo'lsa — rang yo'q (no-color.org kelishuvi);
• FORCE_COLOR=1 — rangni majburan yoqadi.

Kanon buni o'lchadi (holat 20, valyuta kurs USD EUR quvur orqali):

Halol izoh: haqiqiy terminalda (TTY) rang ko'z bilan tekshirilmadi — kanon agenti TTY'siz ishladi. Siz o'z terminalingizda ko'rasiz.

Bu blokdagi chiqish ham quvurga ketadi (biz tekshirganda) — shuning uchun rang qo'shilmadi:

import { styleText } from "node:util";

const matn = styleText("red", "+44.25", { stream: process.stdout });
console.log(JSON.stringify(matn));

Konsolda:

"+44.25"

Kanon format.ts aynan shu usulni ishlatadi: { stream: process.stdout } — "shu oqimga qarab qaror qil". Ustiga --rangsiz bayrog'i ham bor — foydalanuvchi o'zi o'chira oladi.

Nega o'sish qizil, tushish yashil? Kurs — so'mning dollarga nisbati. Dollar qimmatlashsa (+), so'm arzonlashadi — o'zbek foydalanuvchisi uchun yomon xabar. Birja ilovalarida aksincha bo'lishi mumkin — rang ma'nosi kontekstga bog'liq, shuning uchun rang hech qachon yagona belgi bo'lmasin: son oldidagi +/- rangsiz ham ma'noni beradi (kontrast va rang).

Tekshirib ko'ring: valyuta kurs USD > kurs.txt dan keyin fayl ichida rang kodlari bo'ladimi? FORCE_COLOR=1 valyuta kurs USD > kurs.txt chi?

4. inspect va format: obyektni matnga aylantirish

4.1 inspect

console.log(obyekt) ichida aslida util.inspect ishlaydi. Uni to'g'ridan chaqirsangiz, sozlash mumkin:

import { inspect } from "node:util";

const sorov = {
  kesh: "/home/aziz/.cache/valyuta",
  manba: { api: { url: "https://cbu.uz/", urinish: { soni: 2 } } },
};
console.log(inspect(sorov));
const chuqur = { depth: Infinity, breakLength: Infinity };
console.log(inspect(sorov, chuqur));
const birQator = { ...chuqur, compact: true };
console.log(inspect(sorov, birQator).length);

Konsolda:

{
  kesh: '/home/aziz/.cache/valyuta',
  manba: { api: { url: 'https://cbu.uz/', urinish: [Object] } }
}
{
  kesh: '/home/aziz/.cache/valyuta',
  manba: { api: { url: 'https://cbu.uz/', urinish: { soni: 2 } } }
}
103

Birinchi natijada urinish: [Object] — sukut chuqurlik 2. Log faylida bu ko'pincha "muhim ma'lumot ko'rinmayapti" degan muammo. depth: Infinity ichkarini ochdi. Lekin kutilmagan joy bor: breakLength: Infinity bo'lsa ham natija ikki qatorga bo'lindi. Sababi — compact: 3: 3 darajadan chuqur obyekt baribir qatorlarga bo'linadi. Faqat compact: true bilan butun obyekt bitta qatorga tushdi (103 belgi). Log fayllari uchun bu muhim: bitta voqea — bitta qator. Kanon debuglog da breakLength: Infinity ishlatadi — uning sorov obyekti tekis (ichma-ich emas), shuning uchun bitta qatorda chiqadi.

4.2 format

util.format — console.log ning matn qaytaradigan egizagi. %s — satr, %d — son, %o — obyekt, %j — JSON:

import { format } from "node:util";

console.log(format("manba %s, %d kurs", "kesh", 74));
console.log(format("%j", { kod: "USD", kurs: 11903.15 }));
console.log(format("%d%%", 18.5));

Konsolda:

manba kesh, 74 kurs
{"kod":"USD","kurs":11903.15}
18.5%

%% — oddiy foiz belgisi. Bugungi kodda ko'pincha shablon satrlar (`manba ${m}`) qulayroq. format asosan log funksiyalari ichida kerak — debuglog shu formatni qabul qiladi.

4.3 isDeepStrictEqual va util.types

Ikki obyektni "ichigacha" solishtirish:

import { isDeepStrictEqual, types } from "node:util";

const a = { valyutalar: ["USD", "EUR"] };
const b = { valyutalar: ["USD", "EUR"] };
console.log(a === b, isDeepStrictEqual(a, b));
console.log(isDeepStrictEqual([1, 2], ["1", "2"]));
console.log(types.isPromise(Promise.resolve(1)));
console.log(types.isDate(new Date()), types.isRegExp(/USD/));

Konsolda:

false true
false
true
true true

=== — bitta obyektmi; isDeepStrictEqual — tarkibi bir xilmi (turlar ham: 1 va "1" farq). node:assert dagi deepStrictEqual ham shu qoidani ishlatadi — testlarda ko'rgansiz (node:test). Sozlama o'zgarganmi, keshni qayta yozish kerakmi — shunday savollar uchun foydali.

util.types — qiymatning ichki turini aniq tekshiradi. instanceof boshqa "dunyo"dan (iframe, vm, worker) kelgan obyektda yolg'on javob berishi mumkin, types.isDate esa yo'q.

5. promisify, deprecate, debuglog

5.1 promisify: callback'dan Promise'ga

Eski Node API'lari va kutubxonalar oxirgi argument sifatida (xato, natija) callback oladi (callbacklar). promisify ularni Promise qaytaradigan funksiyaga o'giradi (promisify):

import { promisify } from "node:util";

function kursniOl(kod, callback) {
  setTimeout(() => {
    if (kod !== "USD") return callback(new Error(`Noma'lum: ${kod}`));
    callback(null, 11903.15);
  }, 10);
}

const kursniOlP = promisify(kursniOl);
console.log(await kursniOlP("USD"));
try {
  await kursniOlP("XYZ");
} catch (xato) {
  console.log(xato.message);
}

Konsolda:

11903.15
Noma'lum: XYZ

Callback'ga xato berilsa — Promise rad etiladi, null va natija berilsa — bajariladi. Bugun ko'p hollarda kerak emas: fs/promises, timers/promises, stream/promises tayyor bor. Lekin eski paket bilan ishlaganda kerak bo'ladi.

5.2 deprecate: eskirgan funksiya

Kutubxona muallifi funksiyani darhol o'chirmaydi — avval "eskirgan" deb belgilaydi (npm deprecate — butun versiya uchun, bu — bitta funksiya uchun):

import { deprecate } from "node:util";

const eskiKonvert = deprecate(
  (miqdor) => miqdor * 2,
  "eskiKonvert() eskirgan, konvert() ni ishlating",
  "VALYUTA001",
);
console.log(eskiKonvert(1));
console.log(eskiKonvert(2));

Biz ishga tushirdik (stdout va stderr birga):

2
4
(node:8676) [VALYUTA001] DeprecationWarning: eskiKonvert() eskirgan, konvert() ni ishlating
(Use `node --trace-deprecation ...` to show where the warning was created)

Ogohlantirish bir marta chiqdi, garchi funksiya ikki marta chaqirilgan bo'lsa ham. U stderr'ga yoziladi va node --no-deprecation bilan o'chadi. 8676 — jarayon raqami (PID), har safar boshqa. Shuning uchun bu blok tekshiruvchida emas, qo'lda ishga tushirildi — tekshiruvchi --no-warnings bilan ishlaydi va ogohlantirish umuman chiqmaydi.

5.3 debuglog: faqat so'ralganda

Dasturchi ichki holatni ko'rishni xohlaydi, foydalanuvchi esa yo'q. debuglog("valyuta") qaytargan funksiya faqat NODE_DEBUG muhit o'zgaruvchisida valyuta bo'lsa yozadi:

import { debuglog } from "node:util";

const debug = debuglog("valyuta");
debug("so'rov %o", { kod: "USD" });
console.log("yoqilganmi:", debug.enabled);

Konsolda:

yoqilganmi: false

NODE_DEBUG berilmagan — debug(...) hech narsa qilmadi. Kanonning jonli natijasi (NODE_DEBUG=valyuta valyuta kurs USD, holat 20):

VALYUTA 7040: so'rov { kesh: 'C:\\Users\\…\\jonli-kesh', api: undefined, sana: undefined, offline: false, yangila: false }
VALYUTA 7040: manba kesh, 74 kurs
2026-10-23 holatiga (kesh)

Prefiks — katta harfli nom va PID. Log stderr'ga ketadi — valyuta kurs USD > kurs.txt faylni buzmaydi. Node'ning o'zi ham shu mexanizmni ishlatadi: NODE_DEBUG=http,net node server.js — ichki HTTP loglari. Bir necha nom vergul bilan, * belgisi ham ishlaydi (NODE_DEBUG=valyuta*).

6. CLI qadami: bayroqlar parseArgs bilan (holat 20, 1-qism)

Holat 20 ikki darsga bo'lingan: bugun — util, keyingi dars — crypto 1 (kesh kaliti). Hali commit qilmang — commit keyingi darsda.

6.1 Bayroqlar tavsifi

Kanon cli.ts dagi tavsif:

const BAYROQLAR = {
  sana: { type: "string", short: "s" },
  format: { type: "string", short: "f", default: "jadval" },
  yangila: { type: "boolean", default: false },
  offline: { type: "boolean", default: false },
  rangsiz: { type: "boolean", default: false },
  help: { type: "boolean", short: "h", default: false },
  version: { type: "boolean", short: "v", default: false },
} as const;

as const — TypeScript type: "string" ni oddiy string emas, aynan "string" deb tushunsin. Shunda parseArgs qaytargan values.sana turi string | undefined, values.offline esa boolean bo'ladi — tiplar avtomatik.

6.2 Xatoni foydalanuvchi xatosiga aylantirish

function argumentlar(argv: string[]) {
  try {
    return parseArgs({ args: argv, options: BAYROQLAR, allowPositionals: true, strict: true });
  } catch (xato) {
    // ERR_PARSE_ARGS_UNKNOWN_OPTION va h.k. — foydalanuvchi xatosi
    throw new FoydalanishXatosi(xato instanceof Error ? xato.message : String(xato));
  }
}

FoydalanishXatosi ni main ushlaydi: xabar + yordam matni stderr'ga, exit kod 2 ("noto'g'ri foydalanish", exit kodlari). Kanon chiqishi:

$ valyuta kurs --yoq
Xato: Unknown option '--yoq'. To specify a positional argument starting with a '-', place it at the end of the command after '--', as in '-- "--yoq"

Foydalanish:
  valyuta kurs [KOD...]          kurslar (kodsiz — config.json dagi "valyutalar"; "all" — hammasi)
…
[exit 2]

6.3 Versiya: package.json dan

--version uchun versiya raqamini qo'lda yozmaymiz — package.json dan olamiz:

import paket from "../package.json" with { type: "json" };

with { type: "json" } — import atributi (ES Modules Node'da). Yo'l ../package.json — src/cli.ts dan ham, build'dan keyingi dist/cli.js dan ham bir xil joyga tushadi. tsconfig da resolveJsonModule: true kerak. Kanon natijasi: valyuta -v → 0.2.0 — holat 20 dagi package.json versiyasi.

6.4 Rang va debuglog

format.ts dagi jadval funksiyasi farq ustunini styleText(farq > 0 ? "red" : "green", …, { stream: process.stdout }) bilan bo'yaydi; --rangsiz bo'lsa — rangsiz. cli.ts boshida:

const debug = debuglog("valyuta"); // NODE_DEBUG=valyuta
// …
debug("so'rov %s", inspect(sorov, { colors: false, breakLength: Infinity }));

Yangi bayroqlar yordam matnida ham paydo bo'ladi (-s, --sana, -f, --format, --yangila, --offline, --rangsiz, -h, -v). --sana va -f ning ishlashi — sana tekshiruvi va CSV — keyingi darsda tugaydi.

7. Ko'p uchraydigan xatolar

8. Mashqlar

1-mashq (oson): bo'sh joylar

• -f csv dagi f — bayroqning nomi.
• Noma'lum bayroq xato bersin uchun opsiya:
• Quvurda rangni majburan yoqadigan muhit o'zgaruvchisi:
• inspect sukut chuqurligi:
• debuglog ni yoqadigan muhit o'zgaruvchisi:

2-mashq (o'rta): o'zbekcha xato xabari

argumentlarniOqi(args) funksiyasini yozing: parseArgs bilan --sana (string, -s) va --format (string, -f, sukut jadval) ni o'qisin. Xatoda xato.code ga qarab o'zbekcha xabar qaytarsin: noma'lum bayroq → "Noma'lum bayroq. Yordam: valyuta --help", qiymat yo'q → "Bayroqqa qiymat bering". Muvaffaqiyatda — values dan oddiy obyekt ({ ...values }) va positionals.

import { parseArgs } from "node:util";

const XABARLAR = {
  ERR_PARSE_ARGS_UNKNOWN_OPTION:
    "Noma'lum bayroq. Yordam: valyuta --help",
  ERR_PARSE_ARGS_INVALID_OPTION_VALUE: "Bayroqqa qiymat bering",
};

function argumentlarniOqi(args) {
  try {
    const { values, positionals } = parseArgs({
      args,
      options: {
        sana: { type: "string", short: "s" },
        format: { type: "string", short: "f", default: "jadval" },
      },
      allowPositionals: true,
    });
    return { bayroqlar: { ...values }, positionals };
  } catch (xato) {
    return { xato: XABARLAR[xato.code] ?? xato.message };
  }
}

console.log(argumentlarniOqi(["kurs", "USD", "-s", "2026-10-01"]));
console.log(argumentlarniOqi(["kurs", "--sanaa", "2026-10-01"]));
console.log(argumentlarniOqi(["kurs", "-f"]));

{
  bayroqlar: { sana: '2026-10-01', format: 'jadval' },
  positionals: [ 'kurs', 'USD' ]
}
{ xato: "Noma'lum bayroq. Yordam: valyuta --help" }
{ xato: 'Bayroqqa qiymat bering' }

3-mashq (qiyin): yordam matni avtomatik

yordamYoz(options) funksiyasini yozing: parseArgs uchun yozilgan options obyektidan yordam qatorlarini yasasin. Har qator: qisqa nom (-s, yoki 4 bo'sh joy), uzun nom, string bo'lsa <qiymat>, sukut bo'lsa (sukut: …). Boolean'ning false sukutini ko'rsatmang. Toza JS — saytda ham ishlaydi.

function yordamYoz(options) {
  return Object.entries(options).map(([nom, o]) => {
    const qisqa = o.short ? `-${o.short}, ` : "    ";
    const qiymat = o.type === "string" ? " <qiymat>" : "";
    const sukut = o.default !== undefined && o.default !== false
      ? ` (sukut: ${o.default})`
      : "";
    return `  ${qisqa}--${nom}${qiymat}${sukut}`;
  }).join("\n");
}

console.log(yordamYoz({
  sana: { type: "string", short: "s" },
  format: { type: "string", short: "f", default: "jadval" },
  offline: { type: "boolean", default: false },
  help: { type: "boolean", short: "h" },
}));

  -s, --sana <qiymat>
  -f, --format <qiymat> (sukut: jadval)
      --offline
  -h, --help

4-mashq: CLI qadami

cli.ts ni parseArgs ga o'tkazing («CLI qadami» bo'limi): BAYROQLAR, argumentlar(), -v (versiya package.json dan), -h, NODE_DEBUG=valyuta bilan debuglog. format.ts da styleText bilan rangli farq. Tekshiring: valyuta kurs --yoq → exit 2; valyuta -v → versiya; valyuta kurs USD | more (yoki > fayl.txt) — rang kodlarisiz. Commit qilmang.

9. Real ishda

• CLI'lar — ko'p kichik vosita (skriptlar, ichki asboblar) bugun parseArgs bilan yoziladi: bog'liqlik yo'q, ishga tushish tez. Katta CLI'lar (git kabi ichki buyruqlar) uchun — Commander yoki yargs (Commander darsi).
• Loglar — inspect ning depth va breakLength sozlamalari, format — log kutubxonalari (pino, winston) ichida ham shu g'oya.
• Kutubxona muallifi — deprecate bilan API'ni yumshoq o'zgartirish; foydalanuvchiga bir yil ogohlantirish, keyin MAJOR versiyada o'chirish (semver).
• Intervyu savoli: "Rangli chiqishni qachon o'chirish kerak?" — TTY, NO_COLOR, CI loglari.

Xulosa

• parseArgs — kutubxonasiz bayroqlar: type, short, default, multiple; strict noma'lum bayroqni ushlaydi.
• styleText rangni TTY va NO_COLOR ga qarab o'zi o'chiradi (kanon: quvurda 0 kod); FORCE_COLOR — majburan.
• inspect — depth, breakLength; format — %s %d %j; isDeepStrictEqual, util.types — aniq solishtirish va tekshirish.
• promisify — callback'dan Promise; deprecate — bir martalik ogohlantirish; debuglog — faqat NODE_DEBUG bilan.
• Holat 20 ning birinchi qismi tayyor; commit — keyingi darsda.

Keyingi dars: crypto 1: tasodif, hash va HMAC — Math.random nega xavfli, SHA-256 bilan kesh kaliti va holat 20 commit'i.

Manbalar

• Node.js 24 hujjati — Util (parseArgs, styleText, inspect, format, promisify, deprecate, debuglog, types)
• NO_COLOR kelishuvi — https://no-color.org
• ANSI escape kodlari — ECMA-48 standarti