Langkau ke kandungan

Penjana & Pengesah CUIT/CUIL | Alat ID Cukai Argentina

Hasilkan nombor ujian CUIT/CUIL Argentina yang sah atau mengesahkan yang sedia ada. Alat dalam talian percuma untuk pembangun menguji sistem ID cukai dan penggajian dengan pengesahan yang mematuhi AFIP.

Penjana CUIT/CUIL

Masukkan nombor DNI 8 digit atau gunakan penjana rawak

CUIT/CUIL Dijana
20-33872017-4

Menggunakan DNI yang dijana secara rawak

Kalkulator Pemuatan...
📚

Dokumentasi

Penjana dan Pengesah CUIT/CUIL Argentina

Pengenalan

Dalam sistem cukai dan buruh Argentina, anda akan sentiasa menemui dua pengecam kritikal: CUIT (Clave Única de Identificación Tributaria) dan CUIL (Clave Única de Identificación Laboral). Anggap CUIT sebagai ID cukai untuk perniagaan dan individu yang membayar cukai, manakala CUIL mengenal pasti pekerja dalam sistem keselamatan sosial. Kedua-duanya menggunakan format 11 digit dan algoritma pengesahan yang sama, yang menjadikan pengujian aplikasi yang mengendalikan nombor-nombor ini sangat penting.

Apabila membangunkan perisian untuk pasaran Argentina, anda memerlukan data ujian yang sah. Di sinilah alat ini berguna. Anda boleh menjana nombor CUIT/CUIL yang betul dari segi matematik untuk ujian tanpa menggunakan maklumat peribadi sebenar, atau mengesahkan nombor sedia ada untuk memastikan ia mematuhi algoritma rasmi AFIP. Yang sangat berguna ialah alat ini mengendalikan kedua-dua sisi generasi (mencipta nombor yang sah mengikut permintaan) dan sisi pengesahan (menangkap ralat format, kod jenis tidak sah, dan digit pengesahan yang salah sebelum ia menyebabkan isu dalam pengeluaran).

Struktur dan Pengiraan CUIT/CUIL

Memahami Format

Nombor CUIT/CUIL yang sah terdiri daripada 11 digit yang biasanya dipaparkan dalam format XX-XXXXXXXX-X. Begini cara pecahannya:

  1. Kod Jenis (2 digit pertama): Mengenal pasti jenis entiti

    • 20, 23, 24: Individu lelaki (CUIL)
    • 27: Individu perempuan (CUIL)
    • 30, 33, 34: Syarikat dan organisasi (CUIT)
  2. Nombor DNI (8 digit tengah): Untuk individu, ini adalah nombor dokumen identiti kebangsaan mereka (DNI). Perangkap biasa: jika DNI sebenar mempunyai kurang daripada 8 digit, anda mesti mengisi dengan sifar di hadapan. Contohnya, DNI 1234567 menjadi 01234567 dalam CUIT/CUIL. Syarikat menerima nombor yang ditetapkan secara unik.

  3. Digit Pengesahan (digit terakhir): Digit semakan ini mengesahkan nombor keseluruhan menggunakan algoritma berwajaran. Jika digit ini tidak sepadan dengan pengiraan, CUIT/CUIL adalah tidak sah—sesuatu yang sering mengejutkan pembangun apabila membina data ujian secara manual.

Pengiraan Digit Pengesahan

Digit pengesahan menggunakan algoritma berwajaran modulo-11. Begini cara kerjanya:

  1. Ambil 10 digit pertama CUIT/CUIL (kod jenis + DNI)
  2. Darab setiap digit dengan berat yang sepadan: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2
  3. Jumlahkan semua produk
  4. Kira: 11 tolak (jumlah modulo 11)
  5. Tangani kes khas: jika hasilnya 11, guna 0; jika 10, guna 9

Apa yang paling kerap menyusahkan orang adalah kes khas dalam langkah 5. Semasa menguji, anda kadangkala akan mendapat hasil 10 atau 11, dan lupa memetakan ini kepada 9 dan 0 masing-masing menyebabkan kegagalan pengesahan yang sukar untuk diperbaiki jika anda tidak menyedari peraturan ini.

Secara matematis, ini boleh dinyatakan sebagai:

VD=11((i=110di×wi)mod11)VD = 11 - ((\sum_{i=1}^{10} d_i \times w_i) \bmod 11)

Di mana:

  • VDVD adalah digit pengesahan
  • did_i adalah digit ke-ii dari 10 digit pertama
  • wiw_i adalah berat yang sepadan dari jujukan [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
  • Kes khas: jika VD=11VD = 11 maka VD=0VD = 0, jika VD=10VD = 10 maka VD=9VD = 9

Panduan Langkah demi Langkah

Menggunakan Generator

  1. Pilih tab "Generator" di bahagian atas antara muka alat.

  2. Pilih Kod Jenis dari menu dropdown:

    • 20: Lelaki (CUIL)
    • 23: Perniagaan (CUIT)
    • 24: Perniagaan Sementara (CUIT)
    • 27: Perempuan (CUIL)
    • 30: Syarikat (CUIT)
    • 33: Persatuan Sivil (CUIT)
    • 34: Yayasan (CUIT)
  3. Masukkan Nombor DNI (pilihan):

    • Masukkan nombor DNI 8 digit dalam ruang yang disediakan
    • Jika dibiarkan kosong, alat akan menggunakan DNI yang dijana secara rawak
    • Jika anda memasukkan kurang daripada 8 digit, sistem akan menambah sifar di hadapan
  4. Jana DNI Rawak (pilihan):

    • Klik butang "Rawak" untuk menjana nombor DNI 8 digit secara rawak
  5. Lihat CUIT/CUIL yang Dijana:

    • Alat secara automatik memaparkan CUIT/CUIL yang sah berdasarkan input anda
    • Format akan menjadi XX-XXXXXXXX-X dengan digit pengesahan yang betul
  6. Salin Keputusan:

    • Klik ikon salin untuk menyalin CUIT/CUIL yang dijana ke papan klip anda
    • Mesej pengesahan akan muncul apabila berjaya disalin

Menggunakan Pengesah

  1. Pilih tab "Pengesah" di bahagian atas antara muka alat.

  2. Masukkan CUIT/CUIL untuk Disahkan:

    • Masukkan CUIT/CUIL dalam format XX-XXXXXXXX-X
    • Alat akan secara automatik memformat input anda dengan tanda hubung semasa anda menaip
    • Anda juga boleh memasukkan nombor tanpa tanda hubung (XXXXXXXXXXX)
  3. Klik Butang "Sahkan":

    • Alat akan menyemak format, kod jenis, dan digit pengesahan
  4. Lihat Keputusan Pengesahan:

    • Untuk nombor CUIT/CUIL yang sah, mesej kejayaan hijau akan muncul
    • Untuk nombor tidak sah, mesej ralat merah akan menjelaskan isu:
      • Format tidak sah (mesti XX-XXXXXXXX-X)
      • Kod jenis tidak sah (mesti salah satu daripada: 20, 23, 24, 27, 30, 33, 34)
      • Digit pengesahan tidak sah
  5. Maklumat Tambahan:

    • Untuk nombor yang sah, alat memaparkan pecahan komponen:
      • Kod jenis dan maknanya
      • Nombor DNI
      • Digit pengesahan

Kesilapan Biasa dan Amalan Terbaik

Apabila bekerja dengan pengesahan CUIT/CUIL dalam aplikasi anda, berhati-hati dengan perangkap biasa ini:

Isu Sifar Pendahuluan: Pepijat paling biasa yang saya temui melibatkan nombor DNI dengan sifar pendahuluan. Apabila seseorang memasukkan DNI "1234567", kod anda perlu memperlakukannya sebagai "01234567" untuk pembinaan CUIT/CUIL. Banyak implementasi menukar ke integer untuk pemprosesan, yang menghilangkan sifar pendahuluan. Gunakan operasi rentetan dengan penambahan yang betul.

Kekeliruan Kod Jenis: Bukan semua nombor dua digit adalah kod jenis yang sah. Hanya 20, 23, 24, 27, 30, 33, 34 yang berfungsi. Saya telah melihat sistem yang menerima mana-mana awalan dua digit, yang membawa kepada nombor seperti "21-12345678-X" yang gagal pengesahan AFIP. Sentiasa mengesahkan kod jenis sebelum mengira digit pengesahan.

Andaian Jantina: Kod jenis 20 (lelaki) dan 27 (perempuan) tidak boleh digunakan secara bergantian. Jika anda menjana CUIL secara automatik berdasarkan data demografi, pastikan kod jenis anda sepadan dengan jantina sebenar yang didaftarkan dengan RENAPER (pendaftaran kebangsaan Argentina). Ketidakselarasan menyebabkan penolakan apabila individu cuba menggunakan nombor ini dengan perkhidmatan kerajaan.

Pengendalian Sempang: Sesetengah implementasi memerlukan sempang sementara yang lain menolaknya. Amalan terbaik: terima kedua-dua format dalam medan input (dengan atau tanpa sempang), buang sempang sebelum pengesahan, simpan versi tanpa sempang dalam pangkalan data, dan tambah sempang hanya untuk tujuan paparan.

Pengesahan Hilang: Algoritma pengesahan mengesan ralat format tetapi tidak mengesahkan CUIT/CUIL didaftarkan. Dalam pengeluaran, sahkan format terlebih dahulu (pantas), kemudian semak berbanding pangkalan data AFIP (perlahan tetapi berkuasa). Pendekatan dua peringkat ini mengesan ralat ejaan serta memastikan nombor itu nyata.

Ujian Kes Pinggir: Sentiasa uji dengan digit pengesahan 0 dan 9—ini terhasil daripada kes khas dalam algoritma. Juga uji DNI yang bermula dengan sifar untuk memastikan logik penambahan anda berfungsi dengan betul.

Kegunaan dan Aplikasi Praktikal

Pembangunan dan Pengujian

Pembangunan Perisian: Semasa membina aplikasi untuk pasaran Argentina, anda memerlukan data ujian yang lulus pengesahan tanpa menggunakan maklumat pengguna sebenar. Inilah di mana ia menjadi kritikal:

  • Platform e-dagang: Pemproses pembayaran dan sistem pengebilan memerlukan nombor CUIT/CUIL yang sah. Semasa ujian beban, anda mungkin memerlukan ribuan nombor yang sah untuk mensimulasikan pendaftaran pengguna yang realistik.
  • Perisian perakaunan: Modul pelaporan cukai mengesahkan format CUIT/CUIL sebelum diserahkan kepada AFIP. Menguji peraturan pengesahan ini memerlukan nombor yang lulus algoritma digit semakan.
  • Sistem pengurusan sumber manusia: Pemprosesan gaji dan sumbangan keselamatan sosial bergantung kepada nombor CUIL yang sah. Skenario biasa: anda menguji aliran penyertaan pekerja dan perlu mengesahkan bahawa CUIL yang tidak sah mencetuskan mesej ralat yang sesuai.
  • Aplikasi perbankan: Proses KYC (Kenali Pelanggan Anda) mengesahkan CUIT/CUIL sebagai sebahagian daripada pembukaan akaun. Dari pengalaman saya, kes pinggir seperti ketidakselarasan kod jenis sering muncul semasa pengujian integrasi.

Pengisian Pangkalan Data: Semasa mengisi pangkalan data ujian, menggunakan nombor CUIT/CUIL yang sah secara algoritma memastikan kekangan pangkalan data dan pencetus anda berfungsi seperti yang dijangkakan. Ini penting terutamanya apabila menguji skrip migrasi data atau proses ETL yang mengesahkan nombor pengenalan.

Pengujian Pengesahan Borang: Uji kedua-dua laluan yang baik dan keadaan ralat. Hasilkan nombor yang sah untuk mengesahkan penyerahan yang berjaya, kemudian ubah digit pengesahan untuk memastikan pengesahan frontend dan backend anda menangkap ralat sebelum ia mencapai pangkalan data anda.

Pengujian API: Ujian integrasi harus menggunakan nombor CUIT/CUIL yang sah dalam payload permintaan. Ini menghalang negatif palsu di mana ujian gagal kerana data ujian yang tidak sah dan bukannya pepijat sebenar dalam logik API anda.

Automasi QA: Ujian berparameter mendapat manfaat daripada penghasilan CUIT/CUIL dinamik. Daripada mengekodkan keras nilai ujian yang mungkin berkonflik merentas pelaksanaan ujian, hasilkan nombor sah yang segar untuk setiap pelaksanaan ujian.

Tujuan Pendidikan

Mempelajari Algoritma Pengesahan: Algoritma pengesahan CUIT/CUIL menunjukkan aplikasi praktikal aritmetik modulo dan digit semakan berwajaran. Corak yang sama muncul dalam sistem pengenalan lain di seluruh dunia—nombor kad kredit (algoritma Luhn), kod ISBN, dan nombor VAT Eropah semuanya menggunakan pendekatan checksum berwajaran yang serupa. Memahami cara kerja pengesahan CUIT/CUIL memberikan pandangan mengapa algoritma ini wujud: ia menangkap ralat transkripsi seperti digit yang ditukar atau kesilapan digit tunggal.

Mengajar Pengesahan Data: Semasa melatih pembangun junior tentang pengesahan input, sistem CUIT/CUIL menawarkan contoh dunia sebenar yang lebih kompleks daripada pengesahan e-mel tetapi lebih mudah daripada pengesahan kriptografik. Ia menunjukkan prinsip pertahanan berlapis: pengesahan format (11 digit), pengesahan peraturan perniagaan (kod jenis sah), dan pengesahan algoritma (digit semakan).

Pembangunan Perniagaan Antarabangsa: Jika anda membina sistem untuk pasaran Amerika Latin, memahami CUIT/CUIL membantu anda memahami sistem serupa di negara jiran. Brazil mempunyai CPF/CNPJ, Chile mempunyai RUT, dan Uruguay mempunyai RUT—semuanya menggunakan algoritma digit semakan. Corak yang anda pelajari di sini dipindahkan ke sistem tersebut.

Alternatif dan Pertimbangan Pengeluaran

Walaupun alat ini berfungsi baik untuk pembangunan dan pengujian, persekitaran pengeluaran mempunyai keperluan yang berbeza:

Pengesahan Kerajaan Rasmi: Untuk aplikasi langsung, pengesahan algoritma sahaja tidak mencukupi—anda perlu mengesahkan bahawa CUIT/CUIL sebenarnya didaftarkan dengan AFIP (Administración Federal de Ingresos Públicos). AFIP menyediakan perkhidmatan web untuk pengesahan masa nyata, walaupun anda perlu mendaftar dan mengesahkan untuk mengaksesnya. Tangkapan: nombor boleh sah secara matematik tetapi tidak ditugaskan secara rasmi, jadi sentiasa laksanakan kedua-dua lapisan pengesahan dalam pengeluaran.

Perpustakaan dan Pakej: Jika anda mengintegrasikan pengesahan CUIT/CUIL ke dalam kod anda, pertimbangkan perpustakaan yang mantap ini dan bukannya membuat sendiri:

  • JavaScript: validar-cuit pada npm mengendalikan pengesahan dan pemformatan
  • PHP: Perpustakaan afip-php menyediakan pengesahan dan integrasi perkhidmatan web AFIP
  • Python: py-cuit pada PyPI melaksanakan algoritma penuh

Menggunakan perpustakaan yang diselenggara mengurangkan risiko pepijat pelaksanaan dan sering merangkumi kes pinggir yang mungkin anda terlepas dalam kod tersuai.

Pengiraan Manual: Untuk tujuan pembelajaran atau penyahpepijatan, bekerja melalui algoritma secara manual membantu mengukuhkan pemahaman. Dapatkan kalkulator dan sampel CUIT/CUIL, kemudian ikuti proses pendaraban berwajaran langkah demi langkah.

Perkhidmatan Pengesahan Perusahaan: Aplikasi skala besar mungkin mendapat manfaat daripada API pengesahan pihak ketiga yang bukan sahaja menyemak format tetapi juga menyilang-semak dengan pangkalan data komersial. Perkhidmatan ini boleh menandakan perniagaan tidak aktif, mengenal pasti entiti yang dikenakan sekatan, atau memberikan metadata tambahan tentang pemegang CUIT/CUIL.

Sejarah Sistem CUIT/CUIL

Sistem pengenalan CUIT/CUIL di Argentina telah berkembang dengan ketara sejak penubuhannya:

Asal-usul dan Pelaksanaan

CUIT (Clave Única de Identificación Tributaria) pertama kali diperkenalkan di Argentina pada tahun 1970-an sebagai sebahagian daripada usaha untuk memodenkan sistem pengumpulan cukai. Pentadbiran Persekutuan Hasil Awam (AFIP) melaksanakan pengenal pasti unik ini untuk menjejaki pembayar cukai dengan lebih cekap dan mengurangkan pengelakan cukai.

CUIL (Clave Única de Identificación Laboral) kemudiannya diperkenalkan untuk mengenal pasti pekerja dalam sistem keselamatan sosial, mewujudkan perbezaan antara pengenalan cukai dan pengenalan buruh sambil mengekalkan format yang konsisten.

Evolusi dan Digitalisasi

Pada tahun 1990-an, semasa Argentina menjalani reformasi ekonomi yang ketara, sistem CUIT/CUIL menjadi semakin penting untuk menjejaki aktiviti ekonomi. Sistem itu seterusnya didigitalkan, dan sistem pengesahan dalam talian dilaksanakan.

Awal tahun 2000-an menyaksikan pengintegrasian sistem CUIT/CUIL dengan pelbagai perkhidmatan kerajaan digital, menjadikannya komponen penting dalam inisiatif e-kerajaan Argentina. Tempoh ini juga menyaksikan piawaian algoritma pengesahan dan format yang masih digunakan hari ini.

Perkembangan Terkini

Dalam beberapa tahun kebelakangan ini, AFIP telah meningkatkan proses keselamatan dan pengesahan untuk nombor CUIT/CUIL, melaksanakan sistem pengesahan yang lebih canggih dan mengintegrasikannya dengan pangkalan data kerajaan yang lain. Sistem ini kini memainkan peranan penting dalam usaha Argentina untuk memerangi pengelakan cukai dan memformalkan ekonomi.

Hari ini, CUIT/CUIL digunakan bukan sahaja untuk tujuan cukai dan pekerjaan tetapi juga untuk pelbagai aktiviti termasuk perbankan, transaksi hartanah, perkhidmatan utiliti, dan pembelian dalam talian, menjadikannya pengenal pasti penting untuk individu dan perniagaan yang beroperasi di Argentina.

Pertimbangan Pelaksanaan

Apabila melaksanakan pengesahan CUIT/CUIL dalam sistem anda sendiri, pertimbangkan aspek teknikal berikut:

Kestabilan Algoritma: Algoritma pengesahan CUIT/CUIL semasa telah kekal tidak berubah sejak pengstandaran pada tahun 1990-an. Menurut dokumentasi teknikal AFIP, pendekatan digit semakan modulo-11 yang berwajaran dikodifikasikan dalam Resolución General 2854/2010 dan peraturan selanjutnya. Kestabilan ini bermakna pelaksanaan jarang memerlukan kemas kini, tetapi anda perlu memantau pengumuman AFIP untuk sebarang perubahan peraturan.

Pengoptimuman Prestasi: Algoritma pengesahan adalah murah dari segi pengiraan—hanya 10 pendaraban, satu penambahan, dan satu operasi modulo. Untuk sistem aliran tinggi yang memproses ribuan pengesahan per saat, kesesakan biasanya adalah latensi rangkaian semasa mengesahkan terhadap pangkalan data AFIP, bukan algoritma itu sendiri. Pertimbangkan menyimpan cache keputusan pengesahan AFIP dengan TTL yang sesuai (biasanya 24 jam) untuk mengimbangi kesegaran dengan prestasi.

Pengekodan Aksara: Semasa memproses data CUIT/CUIL dari sumber luar (PDF, dokumen imbasan, web scraping), berhati-hati dengan isu pengekodan aksara. Tanda hubung mungkin muncul sebagai em dash (U+2014), en dash (U+2013), atau tanda tolak (U+2212) dan bukannya tanda hubung-tolak standard (U+002D). Normalisasikan ini sebelum pengesahan untuk mencegah negatif palsu.

Pengantarabangsaan: Jika aplikasi anda melayani pelbagai pasaran Amerika Latin, ambil perhatian bahawa CUIT/CUIL Argentina menggunakan modulo-11 dengan wajaran khusus, RUT Chile menggunakan modulo-11 dengan wajaran berbeza, dan CPF/CNPJ Brazil menggunakan modulo-11 dengan corak yang berbeza. Jangan andaikan algoritma adalah sama—setiap sistem negara mempunyai peraturan yang berbeza. Untuk pemahaman yang lebih meluas tentang algoritma digit semakan, lihat standard ISO/IEC 7064 yang mengformalisasikan pelbagai skim pengesahan berasaskan modulo.

Penyimpanan Pangkalan Data: Simpan nombor CUIT/CUIL tanpa tanda hubung sebagai CHAR(11) panjang tetap atau BIGINT jika pangkalan data anda menyokong integer 11 digit tanpa kehilangan ketepatan. Tambahkan kekangan semakan yang mengesahkan digit semakan pada peringkat pangkalan data sebagai jaring keselamatan terhadap data yang rosak. Cipta indeks pada medan ini untuk carian yang cekap apabila pengguna mencari mengikut CUIT/CUIL.

Contoh Kod

Python

1def calculate_verification_digit(type_code, dni):
2    # Tukar ke rentetan dan pastikan DNI mempunyai 8 digit dengan sifar mendahului
3    type_code_str = str(type_code)
4    dni_str = str(dni).zfill(8)
5    
6    # Gabungkan kod jenis dan DNI
7    digits = type_code_str + dni_str
8    
9    # Pemberat untuk setiap kedudukan
10    weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]
11    
12    # Kira jumlah darab
13    sum_products = sum(int(digits[i]) * weights[i] for i in range(10))
14    
15    # Kira digit pengesahan
16    verification_digit = 11 - (sum_products % 11)
17    
18    # Kes khas
19    if verification_digit == 11:
20        verification_digit = 0
21    elif verification_digit == 10:
22        verification_digit = 9
23    
24    return verification_digit
25
26def generate_cuit_cuil(type_code, dni=None):
27    import random
28    
29    # Kod jenis yang sah
30    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
31    
32    if type_code not in valid_type_codes:
33        raise ValueError(f"Kod jenis tidak sah. Mesti salah satu daripada: {valid_type_codes}")
34    
35    # Hasilkan DNI rawak jika tidak disediakan
36    if dni is None:
37        dni = random.randint(10000000, 99999999)
38    
39    # Kira digit pengesahan
40    verification_digit = calculate_verification_digit(type_code, dni)
41    
42    # Format CUIT/CUIL
43    return f"{type_code}-{str(dni).zfill(8)}-{verification_digit}"
44
45def validate_cuit_cuil(cuit_cuil):
46    # Buang tanda hubung jika ada
47    cuit_cuil_clean = cuit_cuil.replace("-", "")
48    
49    # Semak format asas
50    if not cuit_cuil_clean.isdigit() or len(cuit_cuil_clean) != 11:
51        return False, "Format tidak sah"
52    
53    # Ekstrak bahagian
54    type_code = int(cuit_cuil_clean[0:2])
55    dni = int(cuit_cuil_clean[2:10])
56    verification_digit = int(cuit_cuil_clean[10])
57    
58    # Sahkan kod jenis
59    valid_type_codes = [20, 23, 24, 27, 30, 33, 34]
60    if type_code not in valid_type_codes:
61        return False, "Kod jenis tidak sah"
62    
63    # Kira dan bandingkan digit pengesahan
64    calculated_digit = calculate_verification_digit(type_code, dni)
65    if calculated_digit != verification_digit:
66        return False, "Digit pengesahan tidak sah"
67    
68    return True, "CUIT/CUIL sah"
69
70# Contoh penggunaan
71print(generate_cuit_cuil(20, 12345678))  # Hasilkan untuk DNI tertentu
72print(generate_cuit_cuil(27))  # Hasilkan dengan DNI rawak
73print(validate_cuit_cuil("20-12345678-9"))  # Sahkan CUIT/CUIL
74

JavaScript

1function calculateVerificationDigit(typeCode, dni) {
2  // Tukar ke rentetan dan pastikan DNI mempunyai 8 digit dengan sifar mendahului
3  const typeCodeStr = typeCode.toString();
4  const dniStr = dni.toString().padStart(8, '0');
5  
6  // Gabungkan kod jenis dan DNI
7  const digits = typeCodeStr + dniStr;
8  
9  // Pemberat untuk setiap kedudukan
10  const weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2];
11  
12  // Kira jumlah darab
13  let sumProducts = 0;
14  for (let i = 0; i < 10; i++) {
15    sumProducts += parseInt(digits[i]) * weights[i];
16  }
17  
18  // Kira digit pengesahan
19  let verificationDigit = 11 - (sumProducts % 11);
20  
21  // Kes khas
22  if (verificationDigit === 11) {
23    verificationDigit = 0;
24  } else if (verificationDigit === 10) {
25    verificationDigit = 9;
26  }
27  
28  return verificationDigit;
29}
30
31function generateCuitCuil(typeCode, dni) {
32  // Kod jenis yang sah
33  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
34  
35  if (!validTypeCodes.includes(typeCode)) {
36    throw new Error(`Kod jenis tidak sah. Mesti salah satu daripada: ${validTypeCodes.join(', ')}`);
37  }
38  
39  // Hasilkan DNI rawak jika tidak disediakan
40  if (dni === undefined) {
41    dni = Math.floor(Math.random() * 90000000) + 10000000;
42  }
43  
44  // Kira digit pengesahan
45  const verificationDigit = calculateVerificationDigit(typeCode, dni);
46  
47  // Format CUIT/CUIL
48  return `${typeCode}-${dni.toString().padStart(8, '0')}-${verificationDigit}`;
49}
50
51function validateCuitCuil(cuitCuil) {
52  // Buang tanda hubung jika ada
53  const cuitCuilClean = cuitCuil.replace(/-/g, '');
54  
55  // Semak format asas
56  if (!/^\d{11}$/.test(cuitCuilClean)) {
57    return { isValid: false, errorMessage: 'Format tidak sah' };
58  }
59  
60  // Ekstrak bahagian
61  const typeCode = parseInt(cuitCuilClean.substring(0, 2));
62  const dni = parseInt(cuitCuilClean.substring(2, 10));
63  const verificationDigit = parseInt(cuitCuilClean.substring(10, 11));
64  
65  // Sahkan kod jenis
66  const validTypeCodes = [20, 23, 24, 27, 30, 33, 34];
67  if (!validTypeCodes.includes(typeCode)) {
68    return { isValid: false, errorMessage: 'Kod jenis tidak sah' };
69  }
70  
71  // Kira dan bandingkan digit pengesahan
72  const calculatedDigit = calculateVerificationDigit(typeCode, dni);
73  if (calculatedDigit !== verificationDigit) {
74    return { isValid: false, errorMessage: 'Digit pengesahan tidak sah' };
75  }
76  
77  return { isValid: true };
78}
79
80// Contoh penggunaan
81console.log(generateCuitCuil(20, 12345678)); // Hasilkan untuk DNI tertentu
82console.log(generateCuitCuil(27)); // Hasilkan dengan DNI rawak
83console.log(validateCuitCuil("20-12345678-9")); // Sahkan CUIT/CUIL
84

Java

1import java.util.Arrays;
2import java.util.List;
3import java.util.Random;
4
5public class CuitCuilUtils {
6    private static final List<Integer> VALID_TYPE_CODES = Arrays.asList(20, 23, 24, 27, 30, 33, 34);
7    private static final int[] WEIGHTS = {5, 4, 3, 2, 7, 6, 5, 4, 3, 2};
8    
9    public static int calculateVerificationDigit(int typeCode, int dni) {
10        // Tukar ke rentetan dan pastikan DNI mempunyai 8 digit dengan sifar mendahului
11        String typeCodeStr = String.valueOf(typeCode);
12        String dniStr = String.format("%08d", dni);
13        
14        // Gabungkan kod jenis dan DNI
15        String digits = typeCodeStr + dniStr;
16        
17        // Kira jumlah darab
18        int sumProducts = 0;
19        for (int i = 0; i < 10; i++) {
20            sumProducts += Character.getNumericValue(digits.charAt(i)) * WEIGHTS[i];
21        }
22        
23        // Kira digit pengesahan
24        int verificationDigit = 11 - (sumProducts % 11);
25        
26        // Kes khas
27        if (verificationDigit == 11) {
28            verificationDigit = 0;
29        } else if (verificationDigit == 10) {
30            verificationDigit = 9;
31        }
32        
33        return verificationDigit;
34    }
35    
36    public static String generateCuitCuil(int typeCode, Integer dni) {
37        if (!VALID_TYPE_CODES.contains(typeCode)) {
38            throw new IllegalArgumentException("Kod jenis tidak sah. Mesti salah satu daripada: " + VALID_TYPE_CODES);
39        }
40        
41        // Hasilkan DNI rawak jika tidak disediakan
42        if (dni == null) {
43            Random random = new Random();
44            dni = 10000000 + random.nextInt(90000000);
45        }
46        
47        // Kira digit pengesahan
48        int verificationDigit = calculateVerificationDigit(typeCode, dni);
49        
50        // Format CUIT/CUIL
51        return String.format("%d-%08d-%d", typeCode, dni, verificationDigit);
52    }
53    
54    public static ValidationResult validateCuitCuil(String cuitCuil) {
55        // Buang tanda hubung jika ada
56        String cuitCuilClean = cuitCuil.replace("-", "");
57        
58        // Semak format asas
59        if (!cuitCuilClean.matches("\\d{11}")) {
60            return new ValidationResult(false, "Format tidak sah");
61        }
62        
63        // Ekstrak bahagian
64        int typeCode = Integer.parseInt(cuitCuilClean.substring(0, 2));
65        int dni = Integer.parseInt(cuitCuilClean.substring(2, 10));
66        int verificationDigit = Integer.parseInt(cuitCuilClean.substring(10, 11));
67        
68        // Sahkan kod jenis
69        if (!VALID_TYPE_CODES.contains(typeCode)) {
70            return new ValidationResult(false, "Kod jenis tidak sah");
71        }
72        
73        // Kira dan bandingkan digit pengesahan
74        int calculatedDigit = calculateVerificationDigit(typeCode, dni);
75        if (calculatedDigit != verificationDigit) {
76            return new ValidationResult(false, "Digit pengesahan tidak sah");
77        }
78        
79        return new ValidationResult(true, null);
80    }
81    
82    public static class ValidationResult {
83        private final boolean isValid;
84        private final String errorMessage;
85        
86        public ValidationResult(boolean isValid, String errorMessage) {
87            this.isValid = isValid;
88            this.errorMessage = errorMessage;
89        }
90        
91        public boolean isValid() {
92            return isValid;
93        }
94        
95        public String getErrorMessage() {
96            return errorMessage;
97        }
98    }
99    
100    public static void main(String[] args) {
101        // Contoh penggunaan
102        System.out.println(generateCuitCuil(20, 12345678)); // Hasilkan untuk DNI tertentu
103        System.out.println(generateCuitCuil(27, null)); // Hasilkan dengan DNI rawak
104        System.out.println(validateCuitCuil("20-12345678-9").isValid()); // Sahkan CUIT/CUIL
105    }
106}
107

PHP

<?php function calculateVerificationDigit($typeCode, $dni) { // Tukar ke rentetan dan pastikan DNI mempunyai 8 digit dengan sifar mendahului $typeCodeStr = (string)$typeCode; $dniStr = str_pad((string)$dni, 8, '0', STR_PAD_LEFT); // Gabungkan kod jenis dan DNI $digits = $typeCodeStr . $dniStr; // Pemberat untuk setiap kedudukan $weights = [5, 4, 3, 2, 7, 6, 5, 4, 3, 2]; // Kira jumlah darab $sumProducts = 0; for ($i = 0; $i < 10; $i++) { $sumProducts += (int)$digits[$i] * $weights[$i]; } // Kira digit pengesahan $verificationDigit = 11 - ($sumProducts % 11); // Kes khas if ($verificationDigit == 11) { $verificationDigit = 0; } else if ($verificationDigit == 10) { $verificationDigit = 9; } return $verificationDigit; } function generateCuitCuil($typeCode, $dni = null) { // Kod jenis yang sah $validTypeCodes = [20, 23, 24, 27, 30, 33, 34]; if (!in_array($typeCode, $validTypeCodes)) { throw new Exception("Kod jenis tidak sah. Mesti salah satu daripada: " . implode(', ', $validTypeCodes)); } // Hasilkan DNI rawak jika tidak disediakan if ($dni === null) { $dni = rand(10000000, 99999999); } // Kira digit pengesahan $verificationDigit = calculateVerificationDigit($typeCode, $dni); // Format CUIT/CUIL return sprintf("%d-%08d-%d", $typeCode, $dni, $verificationDigit); } function validateCuitCuil($cuitCuil) { // Buang tanda hubung jika ada $cuitCuilClean = str_replace('-', '', $cuitCuil); // Semak format asas if (!preg_match('/^\d{11}$/', $cuitCuilClean)) { return ['isValid' => false, 'errorMessage' => 'Format tidak sah']; } // Ekstrak bahagian $typeCode = (int)substr($cuitCuilClean, 0, 2); $dni = (int)substr($cuitCuilClean, 2, 8); $verificationDigit = (int)substr($cuitCuilClean, 10, 1); // Sahkan kod jenis $validTypeCodes = [20, 23, 24, 27, 30, 33, 34]; if (!in_array($typeCode, $validTypeCodes)) { return ['isValid' => false, 'errorMessage' => 'Kod jenis tidak sah']; } // Kira dan bandingkan digit pengesahan $calculatedDigit = calculateVerificationDigit($typeCode, $dni); if ($calculatedDigit !== $verificationDigit) { return ['isValid' => false, 'errorMessage' => 'Digit pengesahan tidak sah']; } return ['isValid' => true]; } // Contoh penggunaan echo generateCuit ## Soalan Lazim ### Apakah perbezaan antara CUIT dan CUIL? Berikut adalah perbezaan praktisnya: **CUIT** (Clave Única de Identificación Tributaria) mengenal pasti pembayar cukai—individu dan perniagaan yang memfailkan cukai dengan AFIP. **CUIL** (Clave Única de Identificación Laboral) mengenal pasti pekerja dalam sistem keselamatan sosial untuk tujuan pekerjaan dan persaraan. Dalam amalan, ramai individu mempunyai kedua-dua CUIL (dari pekerjaan pertama mereka) dan mungkin kemudian mendapatkan CUIT (jika mereka menjadi bekerja sendiri atau memulakan perniagaan). Nombor-nombor ini menggunakan format dan peraturan pengiraan yang sama, jadi dari perspektif pengesahan, anda mengendalikannya dengan cara yang sama. Perbezaan ini penting untuk tujuan pentadbiran: sistem gaji biasanya bekerja dengan CUIL, manakala sistem pengebilan dan cukai menggunakan CUIT. ### Kod jenis apakah yang digunakan untuk individu dan syarikat? Untuk individu: - 20, 23, 24: Individu lelaki (CUIL) - 27: Individu perempuan (CUIL) Untuk syarikat dan organisasi: - 30: Syarikat (CUIT) - 33: Persatuan Sivil (CUIT) - 34: Yayasan (CUIT) ### Bagaimana digit pengesahan dikira? Algoritma menggunakan pendaraban berwajaran: ambil setiap 10 digit pertama, darab dengan wajaran **5, 4, 3, 2, 7, 6, 5, 4, 3, 2**, jumlahkan hasilnya, kemudian kira 11 tolak (jumlah modulo 11). Dua kes pinggir yang membingungkan: apabila pengiraan menghasilkan 11, gunakan 0 sebagai digit pengesahan; apabila menghasilkan 10, gunakan 9. Kes khas ini wujud kerana digit pengesahan mestilah satu digit (0-9). Ini adalah algoritma semak digit modulo-11, serupa dengan yang digunakan dalam kod ISBN-10 dan sistem pengenalan lain di seluruh dunia. ### Bolehkah saya menggunakan alat ini untuk menjana nombor CUIT/CUIL sebenar yang rasmi? Tidak—alat ini menjana data ujian yang sah dari segi matematik, tetapi nombor-nombor ini tidak didaftarkan secara rasmi dengan AFIP. Anggap seperti menjana nombor kad kredit yang sah menggunakan algoritma Luhn: ia lulus pengesahan format, tetapi tidak disambungkan ke akaun sebenar. Untuk pendaftaran CUIT/CUIL rasmi, individu perlu mengunjungi AFIP dengan DNI mereka, manakala perniagaan mesti melengkapkan prosedur pendaftaran korporat. Alat ini semata-mata untuk pembangunan, pengujian, dan kegunaan pendidikan di mana anda memerlukan data yang kelihatan sah yang tidak akan berkonflik dengan nombor pengenalan sebenar. ### Mengapa pengesahan CUIT/CUIL saya gagal walaupun formatnya kelihatan betul? Apabila pengesahan gagal walaupun formatnya kelihatan betul, semak perkara biasa berikut: 1. **Kod jenis tidak sah**: Hanya 20, 23, 24, 27, 30, 33, 34 yang sah. Menggunakan 21, 25, atau nombor lain akan gagal. 2. **Digit pengesahan salah**: Digit terakhir mesti sepadan dengan pengiraan algoritma. Walaupun menukar satu digit dalam bahagian DNI memerlukan pengiraan semula digit semak. 3. **Isu format**: Mesti tepat 11 digit (XX-XXXXXXXX-X). Berhati-hati dengan ruang tambahan atau angka sifar yang hilang. 4. **Aksara tersembunyi**: Menyalin dan menampal dari PDF atau laman web kadang-kadang memperkenalkan aksara Unicode yang tidak kelihatan yang merosakkan pengesahan. Petua penyahpepijatan yang cepat: keluarkan digit terakhir dan kira semula secara manual. Jika ia tidak sepadan, itulah punca masalahnya. ### Adakah sempang diperlukan dalam nombor CUIT/CUIL? Sempang hanya untuk pemformatan paparan—ia bukan sebahagian daripada nombor sebenar untuk tujuan pengiraan. Apabila anda melihat **20-12345678-9**, algoritma hanya peduli dengan 11 digit: **20123456789**. Kebanyakan pelaksanaan pengesahan menanggalkan sempang sebelum pemprosesan, itulah sebabnya alat kami menerima kedua-dua **20-12345678-9** dan **20123456789**. Dalam API dan pangkalan data, anda biasanya menyimpan versi tanpa sempang dan menambahkan sempang hanya apabila memaparkan kepada pengguna. Pendekatan ini menghalang ketidakseragaman pemformatan daripada menyebabkan kegagalan pengesahan. ### Bolehkah nombor CUIT/CUIL mempunyai kurang daripada 8 digit dalam bahagian DNI? Bahagian DNI mesti sentiasa tepat 8 digit—tiada pengecualian. Jika DNI sebenar seseorang mempunyai kurang digit (yang berlaku dengan DNI lama, bernombor rendah), anda mengisi dengan sifar di hadapan. Contohnya, DNI **1234567** menjadi **01234567** dalam struktur CUIT/CUIL. Ini adalah sumber kerosakan yang kerap apabila menukar antara format DNI dan CUIT/CUIL. Saya telah melihat sistem gagal pengesahan kerana mereka lupa mengisi sifar, melayan **1234567** sebagai nombor 7 digit dan bukannya **01234567**. Sentiasa gunakan fungsi pengisian sifar dalam kod anda dan bukannya penggabungan rentetan mudah. ### Bagaimana saya boleh mengesahkan sama ada CUIT/CUIL didaftarkan secara rasmi di Argentina? Alat kami mengesahkan ketepatan matematik—format, kod jenis, dan digit semak. Tetapi ia tidak dapat memberitahu anda sama ada nombor itu didaftarkan secara rasmi dengan AFIP atau milik seseorang atau perniagaan sebenar. Untuk pengesahan rasmi, gunakan [perkhidmatan web AFIP](https://www.afip.gob.ar/) atau alat carian "Constancia de Inscripción" mereka. AFIP menawarkan API untuk pengesahan automatik, walaupun anda perlu mendaftar sebagai pembangun dan mengesahkan. Dalam persekitaran pengeluaran, laksanakan kedua-dua lapisan: pertama jalankan pengesahan algoritma (cepat, menangkap kesilapan taip dan ralat format), kemudian semak berbanding pangkalan data AFIP (lebih perlahan, tetapi mengesahkan nombor itu sebenar dan aktif). ### Bolehkah saya menggunakan alat ini dalam aplikasi komersial saya? Ya—algoritma pengesahan CUIT/CUIL adalah standard awam yang ditakrifkan oleh AFIP, jadi anda boleh melaksanakannya dengan bebas dalam perisian komersial. Contoh kod yang disediakan di sini adalah contoh rujukan. Untuk kegunaan pengeluaran, pertimbangkan amalan terbaik ini: laksanakan pengendalian ralat yang betul untuk kes pinggir, tambahkan log untuk menyahpepijat kegagalan pengesahan, semak berbanding pangkalan data rasmi AFIP (bukan hanya pengesahan algoritma), dan kekalkan pelaksanaan anda terkini jika AFIP mengubah peraturan (walaupun algoritma semasa telah stabil selama beberapa dekad). ### Adakah alat ini menyimpan mana-mana nombor CUIT/CUIL yang dijana atau disahkan? Tidak—semua pemprosesan berlaku dalam pelayar anda (sisi pelanggan). Apabila anda menjana atau mengesahkan CUIT/CUIL, pengiraan berjalan secara tempatan menggunakan JavaScript. Tiada apa-apa dihantar ke pelayan kami, dan kami tidak log, simpan, atau jejaki mana-mana nombor yang anda masukkan atau jana. Pendekatan sisi pelanggan ini memastikan privasi dan juga bermakna alat berfungsi luar talian sebaik sahaja halaman dimuatkan. Anda boleh mengesahkan ini dengan membuka alat pembangun pelayar anda dan memerhati tab rangkaian—anda tidak akan melihat sebarang permintaan dihantar semasa menjana atau mengesahkan nombor. ## Rujukan 1. AFIP (Pentadbiran Persekutuan Hasil Awam). "CUIT/CUIL/CDI." Laman Web Rasmi. [https://www.afip.gob.ar/](https://www.afip.gob.ar/) 2. Kementerian Kerja, Pekerjaan dan Keselamatan Sosial. "CUIL - Kunci Pengenalan Buruh Tunggal." [https://www.argentina.gob.ar/trabajo](https://www.argentina.gob.ar/trabajo) 3. ANSES (Pentadbiran Keselamatan Sosial Kebangsaan). "Dapatkan CUIL saya." [https://www.anses.gob.ar/](https://www.anses.gob.ar/) 4. Buletin Rasmi Republik Argentina. "Resolusi Am AFIP 2854/2010: Prosedur. Kunci Pengenalan Cukai Tunggal (C.U.I.T.)." 5. Kod Fiskal Republik Argentina. "Pengenalan dan Pendaftaran Pembayar Cukai." --- Sama ada anda membina sistem invois, menguji aliran penyertaan pekerja, atau mempelajari algoritma pengesahan, alat ini menyediakan generasi dan pengesahan CUIT/CUIL yang anda perlukan. Hasilkan data ujian yang lulus pengesahan algoritma, sahkan nombor sebelum ia mencapai pangkalan data anda, atau siasat cara algoritma digit semakan berfungsi dalam amalan.