Ģenerējiet derīgus Brazīlijas CNPJ numurus un validējiet esošos ar šo vienkāršo rīku, kas izstrādāts izstrādātājiem un testētājiem, kuri strādā ar Brazīlijas uzņēmumu ID.
Izveidojiet derīgu Brazīlijas CNPJ numuru testēšanas nolūkiem.
Pārbaudiet, vai Brazīlijas CNPJ numurs ir derīgs.
Brazīliešu CNPJ (Cadastro Nacional da Pessoa Jurídica) ir unikāls identifikācijas numurs, kas piešķirts uzņēmumiem un juridiskām personām Brazīlijā. Šis Brazīliešu CNPJ ģenerators un validētājs nodrošina vienkāršu un efektīvu veidu, kā ģenerēt derīgus CNPJ numurus testēšanas mērķiem un validēt esošos CNPJ numurus saskaņā ar oficiālo Brazīlijas algoritmu. Neatkarīgi no tā, vai esat izstrādātājs, kas testē lietojumprogrammas, kas apstrādā Brazīlijas uzņēmumu datus, QA profesionālis, kas izveido testēšanas gadījumus, vai ikviens, kas strādā ar Brazīlijas uzņēmumu informāciju, šis rīks atvieglo darbu ar CNPJ numuriem.
Atšķirībā no reāliem CNPJ numuriem, kurus oficiāli izsniedz Brazīlijas Federālā ieņēmumu dienesta (Receita Federal), šie rīka ģenerētie CNPJ ir matemātiski derīgi, bet nav reģistrēti reālām kompānijām. Tas padara tos ideāli piemērotus testēšanas scenārijiem, paraugu datiem un izstrādes vidēm, kur nepieciešami pareizi formatēti un derīgi CNPJ numuri, neizmantojot reālus uzņēmumu identifikatorus.
CNPJ (Cadastro Nacional da Pessoa Jurídica) ir 14 ciparu identifikācijas numurs, ko piešķir uzņēmumiem un juridiskām personām Brazīlijas Federālais ieņēmumu dienests. Tas kalpo kā Brazīlijas ekvivalents uzņēmuma reģistrācijas numuram vai nodokļu ID. Katram uzņēmumam, kas legāli darbojas Brazīlijā, ir jābūt CNPJ, kas tiek izmantots:
CNPJ ir būtisks identifikators Brazīlijas uzņēmējdarbības ekosistēmā un parādās oficiālos dokumentos, līgumos un finanšu ierakstos.
Brazīliešu CNPJ sastāv no 14 cipariem, parasti formatēti kā: XX.XXX.XXX/YYYY-ZZ
Struktūra sadalās šādi:
Piemēram, pareizi formatēts CNPJ var izskatīties šādi: 12.345.678/0001-95
Pārbaudes cipari (pēdējie divi numuri) tiek aprēķināti, izmantojot specifisku matemātisko algoritmu, kas validē CNPJ autentiskumu. Šis algoritms nodrošina, ka nejauši ģenerēti numuri nevar iziet validāciju, neievērojot pareizo aprēķina metodi.
CNPJ validācijas algoritms izmanto svaru aprēķinu, lai noteiktu pārbaudes ciparus. Lūk, kā tas darbojas:
Lai CNPJ būtu derīgs, abiem pārbaudes cipariem jāatbilst aprēķinātajām vērtībām.
Mūsu Brazīliešu CNPJ ģeneratora un validētāja rīks piedāvā divas galvenās funkcijas: derīgu CNPJ ģenerēšanu un esošo CNPJ numuru validēšanu.
Lai ģenerētu derīgu CNPJ testēšanas mērķiem:
Ģenerētais CNPJ sekos visām matemātiskās validācijas noteikumiem, kas attiecas uz reālu CNPJ, bet nav reģistrēts Brazīlijas Federālajā ieņēmumu dienestā.
Lai pārbaudītu, vai CNPJ ir matemātiski derīgs:
Validētājs pārbauda, vai CNPJ atbilst pareizajai formai un vai pārbaudes cipari atbilst gaidāmajām vērtībām saskaņā ar validācijas algoritmu.
Šis Brazīliešu CNPJ ģeneratora un validētāja rīks ir īpaši noderīgs šādos scenārijos:
Lai gan mūsu rīks nodrošina vienkāršu, pārlūkprogrammā balstītu risinājumu CNPJ ģenerēšanai un validēšanai, ir vairāki alternatīvi risinājumi atkarībā no jūsu specifiskajām vajadzībām:
Izstrādātājiem, kas integrē CNPJ validāciju tieši lietojumprogrammās, ir pieejamas vairākas valodas specifiskas bibliotēkas:
cpf_cnpj.js, validator.jspython-cnpj, validate-docbrbrazilianutils, respect/validationcaelum-stella, commons-validatorcpf_cnpj, brazilian-railsŠīs bibliotēkas bieži piedāvā papildu funkcionalitāti, piemēram, formatēšanu, parsēšanu un citu Brazīlijas dokumentu validāciju.
Lietojumprogrammām, kas prasa validāciju bez algoritma ieviešanas:
Izglītības nolūkiem vai vienreizējām validācijām jūs varat manuāli piemērot algoritmu:
Tomēr manuāla aprēķināšana ir kļūdaina un neefektīva regulārai lietošanai.
CNPJ ģenerators un validētājs šajā rīkā ir īstenots, izmantojot JavaScript, padarot to ātru un spējīgu darboties pilnībā jūsu pārlūkā, nesūtot datus uz serveri. Lūk, kā darbojas galvenās funkcijas:
1function generateCNPJ() {
2 // Ģenerē pirmos 12 ciparus nejauši
3 const digits = Array.from({ length: 12 }, () => Math.floor(Math.random() * 10));
4
5 // Aprēķina pirmo pārbaudes ciparu
6 const firstCheckDigit = calculateCheckDigit(digits);
7 digits.push(firstCheckDigit);
8
9 // Aprēķina otro pārbaudes ciparu
10 const secondCheckDigit = calculateCheckDigit(digits);
11 digits.push(secondCheckDigit);
12
13 // Formatē CNPJ
14 return formatCNPJ(digits.join(''));
15}
16
17function calculateCheckDigit(digits) {
18 const weights = digits.length < 13
19 ? [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
20 : [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
21
22 const sum = digits.reduce((acc, digit, index) => {
23 return acc + digit * weights[index];
24 }, 0);
25
26 const remainder = sum % 11;
27 return remainder < 2 ? 0 : 11 - remainder;
28}
291function validateCNPJ(cnpj) {
2 // Noņem ne-numeriskos simbolus
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // Pārbauda, vai tam ir pareizais garums
6 if (cleanCNPJ.length !== 14) return false;
7
8 // Pārbauda pazīstamus nederīgus paraugus (visi vienādi cipari)
9 if (/^(\d)\1+$/.test(cleanCNPJ)) return false;
10
11 // Pārvērš ciparus par ciparu masīvu
12 const digits = cleanCNPJ.split('').map(Number);
13
14 // Pārbauda pirmo verifikācijas ciparu
15 const expectedFirstDigit = calculateCheckDigit(digits.slice(0, 12));
16 if (digits[12] !== expectedFirstDigit) return false;
17
18 // Pārbauda otro verifikācijas ciparu
19 const expectedSecondDigit = calculateCheckDigit(digits.slice(0, 13));
20 if (digits[13] !== expectedSecondDigit) return false;
21
22 return true;
23}
241function formatCNPJ(cnpj) {
2 // Noņem ne-numeriskos simbolus
3 const cleanCNPJ = cnpj.replace(/\D/g, '');
4
5 // Formatē pēc garuma
6 if (cleanCNPJ.length <= 2) {
7 return cleanCNPJ;
8 } else if (cleanCNPJ.length <= 5) {
9 return `${cleanCNPJ.slice(0, 2)}.${cleanCNPJ.slice(2)}`;
10 } else if (cleanCNPJ.length <= 8) {
11 return `${cleanCNPJ.slice(0, 2)}.${cleanCNPJ.slice(2, 5)}.${cleanCNPJ.slice(5)}`;
12 } else if (cleanCNPJ.length <= 12) {
13 return `${cleanCNPJ.slice(0, 2)}.${cleanCNPJ.slice(2, 5)}.${cleanCNPJ.slice(5, 8)}/${cleanCNPJ.slice(8)}`;
14 } else {
15 return `${cleanCNPJ.slice(0, 2)}.${cleanCNPJ.slice(2, 5)}.${cleanCNPJ.slice(5, 8)}/${cleanCNPJ.slice(8, 12)}-${cleanCNPJ.slice(12, 14)}`;
16 }
17}
18Šīs galvenās funkcijas var īstenot citās programmēšanas valodās, sekojot tai pašai loģikai. Šeit ir piemēri Python un Java valodās:
1import random
2
3def calculate_check_digit(digits):
4 weights = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2] if len(digits) < 13 else [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
5
6 total = 0
7 for i in range(len(digits)):
8 total += digits[i] * weights[i]
9
10 remainder = total % 11
11 return 0 if remainder < 2 else 11 - remainder
12
13def generate_cnpj():
14 # Ģenerē pirmos 12 ciparus nejauši
15 digits = [random.randint(0, 9) for _ in range(12)]
16
17 # Aprēķina pirmo pārbaudes ciparu
18 first_check = calculate_check_digit(digits)
19 digits.append(first_check)
20
21 # Aprēķina otro pārbaudes ciparu
22 second_check = calculate_check_digit(digits)
23 digits.append(second_check)
24
25 # Formatē CNPJ
26 cnpj = ''.join(map(str, digits))
27 return f"{cnpj[:2]}.{cnpj[2:5]}.{cnpj[5:8]}/{cnpj[8:12]}-{cnpj[12:]}"
28
29def validate_cnpj(cnpj):
30 # Noņem ne-numeriskos simbolus
31 cnpj = ''.join(filter(str.isdigit, cnpj))
32
33 # Pārbauda garumu
34 if len(cnpj) != 14:
35 return False
36
37 # Pārbauda, vai visi cipari ir vienādi
38 if len(set(cnpj)) == 1:
39 return False
40
41 # Pārvērš ciparus par ciparu masīvu
42 digits = [int(d) for d in cnpj]
43
44 # Validē pirmo pārbaudes ciparu
45 first_check = calculate_check_digit(digits[:12])
46 if digits[12] != first_check:
47 return False
48
49 # Validē otro pārbaudes ciparu
50 second_check = calculate_check_digit(digits[:13])
51 if digits[13] != second_check:
52 return False
53
54 return True
551import java.util.Random;
2
3public class CNPJUtils {
4
5 public static String generateCNPJ() {
6 Random random = new Random();
7 int[] digits = new int[14];
8
9 // Ģenerē pirmos 12 ciparus nejauši
10 for (int i = 0; i < 12; i++) {
11 digits[i] = random.nextInt(10);
12 }
13
14 // Aprēķina pirmo pārbaudes ciparu
15 digits[12] = calculateCheckDigit(digits, 12);
16
17 // Aprēķina otro pārbaudes ciparu
18 digits[13] = calculateCheckDigit(digits, 13);
19
20 // Formatē CNPJ
21 return String.format("%02d.%03d.%03d/%04d-%02d",
22 digits[0] * 10 + digits[1],
23 digits[2] * 100 + digits[3] * 10 + digits[4],
24 digits[5] * 100 + digits[6] * 10 + digits[7],
25 digits[8] * 1000 + digits[9] * 100 + digits[10] * 10 + digits[11],
26 digits[12] * 10 + digits[13]);
27 }
28
29 private static int calculateCheckDigit(int[] digits, int length) {
30 int[] weights = length < 13
31 ? new int[]{5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2}
32 : new int[]{6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2};
33
34 int sum = 0;
35 for (int i = 0; i < length; i++) {
36 sum += digits[i] * weights[i];
37 }
38
39 int remainder = sum % 11;
40 return remainder < 2 ? 0 : 11 - remainder;
41 }
42
43 public static boolean validateCNPJ(String cnpj) {
44 // Noņem ne-numeriskos simbolus
45 cnpj = cnpj.replaceAll("\\D", "");
46
47 // Pārbauda garumu
48 if (cnpj.length() != 14) {
49 return false;
50 }
51
52 // Pārbauda, vai visi cipari ir vienādi
53 boolean allDigitsSame = true;
54 for (int i = 1; i < cnpj.length(); i++) {
55 if (cnpj.charAt(i) != cnpj.charAt(0)) {
56 allDigitsSame = false;
57 break;
58 }
59 }
60 if (allDigitsSame) {
61 return false;
62 }
63
64 // Pārvērš ciparus par ciparu masīvu
65 int[] digits = new int[14];
66 for (int i = 0; i < 14; i++) {
67 digits[i] = Character.getNumericValue(cnpj.charAt(i));
68 }
69
70 // Validē pirmo pārbaudes ciparu
71 int firstCheck = calculateCheckDigit(digits, 12);
72 if (digits[12] != firstCheck) {
73 return false;
74 }
75
76 // Validē otro pārbaudes ciparu
77 int secondCheck = calculateCheckDigit(digits, 13);
78 if (digits[13] != secondCheck) {
79 return false;
80 }
81
82 return true;
83 }
84}
85Izmantojot šo CNPJ ģeneratora un validētāja rīku, ņemiet vērā šādus apsvērumus:
CNPJ ir nacionālais reģistrācijas numurs uzņēmumiem un juridiskām personām Brazīlijā. To izmanto nodokļu mērķiem, uzņēmuma reģistrācijai, bankas kontu atvēršanai un uzņēmumu identificēšanai oficiālās transakcijās.
Nē. Šī rīka ģenerētie CNPJ ir matemātiski derīgi saskaņā ar pārbaudes ciparu algoritmu, taču tie nav reģistrēti Brazīlijas Federālajā ieņēmumu dienestā un nepieder reālām kompānijām.
Nē. Lai iegūtu likumīgu CNPJ uzņēmumam, jums ir jāreģistrējas Brazīlijas Federālajā ieņēmumu dienestā (Receita Federal), ievērojot oficiālo procesu. Ģenerētie CNPJ ir paredzēti tikai testēšanai.
Lai pārbaudītu, vai CNPJ ir reģistrēts faktiskam uzņēmumam, jums jākonsultējas ar Brazīlijas Federālā ieņēmumu dienesta datu bāzi. Mūsu rīks pārbauda tikai matemātisko derīgumu, nevis oficiālo reģistrāciju.
CNPJ ar visiem vienādiem cipariem (piemēram, 11.111.111/1111-11) automātiski tiek uzskatīts par nederīgu, pat ja tas matemātiski iziet pārbaudi. Tas ir noteikums, ko noteicis Brazīlijas Federālais ieņēmumu dienests.
Nē. Visa apstrāde notiek jūsu pārlūkā, un mēs neglabājam vai nesūtām nekādu informāciju par CNPJ, ko jūs ģenerējat vai validējat.
Pašreizējā rīka versija ģenerē vienu CNPJ vienlaikus. Lielai ģenerēšanai varat apsvērt iespēju izmantot kādu no programmēšanas bibliotēkām, kas minētas alternatīvu sadaļā.
Tas ir oficiālais formāts, ko prasa Brazīlijas iestādes. Specifiskā grupēšana palīdz identificēt dažādus CNPJ komponentus, piemēram, bāzes numuru un filiāles identifikatoru.
Jūs varat īstenot validācijas algoritmu savā izvēlētajā programmēšanas valodā, izmantojot tehniskās īstenošanas sadaļā sniegtos koda piemērus, vai izmantot kādu no alternatīvās sadaļā minētajām bibliotēkām.
Jā. Valdības iestādēm Brazīlijā ir specifiski CNPJ modeļi. Piemēram, federālās valdības iestādes bieži sākas ar noteiktiem cipariem. Mūsu ģenerators ģenerē nejaušus CNPJ un nenodrošina speciāli valdības iestāžu CNPJ.
Mūsu Brazīliešu CNPJ ģeneratora un validētāja rīks padara darbu ar šiem identifikācijas numuriem vienkāršu un efektīvu. Neatkarīgi no tā, vai testējat lietojumprogrammas, sagatavojat paraugu datus vai validējat esošos CNPJ, šis rīks nodrošina vienkāršu risinājumu bez API integrācijas vai sarežģītām konfigurācijām.
Ģenerējiet savu pirmo derīgo CNPJ tagad vai validējiet esošo, izmantojot mūsu vienkāršo saskarni!
Atklājiet vairāk rīku, kas varētu būt noderīgi jūsu darbplūsmai