Pengesahan Sintaks E-mel: Corak Regex 2025

Pengesahan sintaks e-mel membentuk asas bagi mana-mana sistem pengesahan e-mel yang teguh. Sebelum memeriksa sama ada alamat e-mel benar-benar wujud atau boleh menerima mesej, anda mesti terlebih dahulu mengesahkan bahawa alamat tersebut mengikut format yang betul. Walaupun ini kelihatan mudah, pengesahan sintaks e-mel menyimpan kerumitan yang mengejutkan dan mengelirukan ramai pembangun. Memahami nuansa pengesahan format e-mel membantu anda membina pengesah e-mel yang lebih baik dan mengelakkan perangkap biasa yang membawa kepada penolakan alamat yang sah atau penerimaan alamat yang salah format.

Memahami Struktur Alamat E-mel

Setiap alamat e-mel terdiri daripada dua bahagian utama yang dipisahkan oleh simbol "@": bahagian tempatan dan bahagian domain. Struktur lengkap mengikut corak local-part@domain. Walaupun ini kelihatan mudah, peraturan yang mengawal setiap bahagian—ditakrifkan terutamanya oleh RFC 5321 dan RFC 5322—membenarkan variasi yang besar yang gagal dikendalikan dengan betul oleh banyak corak regex pengesahan e-mel asas.

Bahagian Tempatan

Bahagian tempatan muncul sebelum simbol "@" dan mengenal pasti peti mel tertentu pada pelayan mel. Aksara yang sah dalam bahagian tempatan termasuk:

• Huruf besar dan kecil (A-Z, a-z)
• Digit (0-9)
• Aksara khas: ! # $ % & ' * + - / = ? ^ _ ` { | } ~
• Titik (.) apabila tidak di permulaan atau akhir, dan tidak berturut-turut
• Rentetan berpetikan yang membenarkan hampir semua aksara, termasuk ruang dan aksara khas

Fleksibiliti ini bermakna alamat seperti user+tag@domain.com, "john doe"@example.com, dan admin!special@company.org semuanya sah secara teknikal mengikut spesifikasi. Pemeriksa e-mel yang terlalu ketat mungkin secara salah menolak alamat yang sah ini.

Bahagian Domain

Bahagian domain mengikuti simbol "@" dan menentukan ke mana e-mel harus dihantar. Format domain yang sah termasuk:

• Nama domain standard (example.com, mail.company.org)
• Nama domain antarabangsa dengan aksara bukan ASCII
• Alamat IP dalam kurungan ([192.168.1.1] atau [IPv6:2001:db8::1])

Nama domain mesti mengikut konvensyen penamaan DNS: label yang dipisahkan oleh titik, setiap label bermula dan berakhir dengan aksara alfanumerik, hanya mengandungi aksara alfanumerik dan tanda tolak di antaranya.

Cabaran Regex Pengesahan E-mel

Mencipta corak regex yang mengesahkan alamat e-mel dengan tepat sambil mengikut spesifikasi RFC terbukti sangat sukar. Jurang antara apa yang biasa dilaksanakan oleh pembangun dan apa yang sebenarnya dibenarkan oleh standard mencipta masalah berterusan dalam sistem pengesahan e-mel di seluruh dunia.

Mengapa Corak Regex Mudah Gagal

Banyak tutorial dan contoh kod menyediakan corak regex pengesahan e-mel yang terlalu dipermudahkan seperti:

^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

Walaupun corak ini menangkap alamat yang jelas tidak sah, ia secara salah menolak alamat yang sah yang mengandungi:

• Bahagian tempatan berpetikan dengan ruang
• Aksara khas seperti ! atau # dalam bahagian tempatan
• Domain peringkat atas satu aksara (ya, ia wujud)
• Bahagian domain alamat IP

Sebaliknya, corak ini mungkin menerima alamat tidak sah dengan:

• Titik berturut-turut dalam bahagian tempatan
• Titik pada permulaan atau akhir bahagian tempatan
• Label domain yang bermula atau berakhir dengan tanda tolak

Regex RFC 5322

Regex terkenal yang mematuhi RFC 5322 menunjukkan kerumitan sebenar pengesahan sintaks e-mel. Corak ini, merangkumi berbilang baris, cuba menangkap spesifikasi penuh:

(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])

Regex ini, walaupun lebih tepat, mencipta mimpi ngeri penyelenggaraan, kebimbangan prestasi, dan cabaran penyahpepijatan. Sedikit pembangun boleh membaca atau mengubahsuainya dengan yakin, dan kerumitannya boleh menyebabkan backtracking bencana dalam enjin regex tertentu.

Corak Regex Pengesahan E-mel Praktikal

Daripada mengejar pematuhan RFC yang sempurna, kebanyakan aplikasi mendapat manfaat daripada corak regex praktikal yang mengimbangi ketepatan dengan kebolehselenggaraan. Matlamatnya adalah untuk menangkap alamat yang benar-benar tidak sah sambil menerima format e-mel yang sebenarnya digunakan oleh pengguna sebenar.

Corak Kegunaan Umum yang Disyorkan

Untuk kebanyakan aplikasi web, regex pengesahan e-mel yang seimbang ini berfungsi dengan baik:

const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

Corak ini memastikan:

• Sekurang-kurangnya satu aksara sebelum @
• Tepat satu simbol @
• Sekurang-kurangnya satu aksara antara @ dan titik terakhir
• Sekurang-kurangnya satu aksara selepas titik terakhir
• Tiada ruang di mana-mana dalam alamat

Walaupun tidak lengkap mengikut RFC, corak ini menerima hampir semua alamat e-mel dunia sebenar sambil menolak kesilapan pemformatan yang jelas.

Corak Dipertingkat dengan Lebih Banyak Sekatan

Untuk aplikasi yang memerlukan pengesahan yang lebih ketat, pertimbangkan:

const strictEmailRegex = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;

Corak ini menambah:

• Senarai putih aksara eksplisit untuk bahagian tempatan
• Had panjang label domain (maksimum 63 aksara)
• Pencegahan tanda tolak berturut-turut pada sempadan domain

Pelaksanaan Khusus Bahasa

Bahasa pengaturcaraan yang berbeza mengendalikan regex pengesahan e-mel secara berbeza. Berikut adalah corak yang dioptimumkan untuk bahasa biasa:

JavaScript:

function validateEmailSyntax(email) {
  const pattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return pattern.test(email) && email.length <= 254;
}

Python:

import re

def validate_email_syntax(email):
    pattern = r'^[^\s@]+@[^\s@]+\.[^\s@]+$'
    if len(email) > 254:
        return False
    return bool(re.match(pattern, email))

PHP:

function validateEmailSyntax($email) {
    return filter_var($email, FILTER_VALIDATE_EMAIL) !== false;
}

Perhatikan bahawa fungsi terbina dalam filter_var PHP menyediakan pengesahan sintaks e-mel yang munasabah tanpa memerlukan corak regex khusus.

Melangkaui Sintaks Asas: Kekangan Panjang

Pengesahan sintaks e-mel juga mesti menguatkuasakan kekangan panjang yang mungkin tidak dapat ditangani secukupnya oleh corak regex sahaja.

Had Panjang Keseluruhan

RFC 5321 menyatakan bahawa alamat e-mel tidak boleh melebihi 254 aksara keseluruhan. Had ini terpakai kepada alamat lengkap termasuk bahagian tempatan, simbol @, dan bahagian domain digabungkan.

Panjang Bahagian Tempatan

Bahagian tempatan tidak boleh melebihi 64 aksara. Alamat dengan bahagian tempatan yang lebih panjang harus ditolak walaupun ia sebaliknya sepadan dengan corak regex anda.

Panjang Domain

Label domain individu tidak boleh melebihi 63 aksara, dan jumlah bahagian domain tidak boleh melebihi 253 aksara. Had ini berasal dari spesifikasi DNS dan bukannya standard e-mel.

Melaksanakan Semakan Panjang

Sentiasa gabungkan pengesahan regex dengan semakan panjang eksplisit:

function validateEmail(email) {
  // Kekangan panjang
  if (email.length > 254) return false;

  const [localPart, domain] = email.split('@');
  if (!localPart || !domain) return false;
  if (localPart.length > 64) return false;
  if (domain.length > 253) return false;

  // Semak label domain individu
  const labels = domain.split('.');
  for (const label of labels) {
    if (label.length > 63) return false;
  }

  // Pengesahan regex
  const pattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return pattern.test(email);
}

Kesilapan Biasa Pengesahan Sintaks E-mel

Memahami kesilapan pengesahan biasa membantu anda membina pengesah e-mel yang lebih baik dan mengelakkan pengguna kecewa dengan penolakan palsu.

Memerlukan Panjang TLD

Sesetengah corak memerlukan domain peringkat atas sekurang-kurangnya 2 atau 3 aksara. Walaupun TLD biasa seperti .com, .org, dan .net adalah 3+ aksara, TLD satu aksara yang sah wujud, dan gTLD baharu berbeza-beza dalam panjang.

Menyekat Tanda Tambah

Tanda tambah (+) adalah sah dalam bahagian tempatan e-mel dan biasa digunakan untuk penandaan e-mel (contohnya, user+newsletter@gmail.com). Menyekat tanda tambah menghalang pengguna daripada menyusun e-mel mereka dan mengecewakan pengguna mahir.

Memerlukan Aksara Tertentu

Sesetengah pengesah memerlukan aksara tertentu (seperti sekurang-kurangnya satu huruf) dalam bahagian tempatan. Alamat seperti 123@domain.com adalah sah sepenuhnya dan kadang-kadang digunakan.

Andaian Sensitiviti Kes

Walaupun bahagian domain tidak sensitif kes, bahagian tempatan secara teknikal sensitif kes mengikut RFC 5321. Walau bagaimanapun, kebanyakan pelayan mel moden menganggap bahagian tempatan sebagai tidak sensitif kes dalam praktik. Pengesah anda harus menerima mana-mana kes tetapi menormalkan kepada huruf kecil untuk penyimpanan.

Penolakan Aksara Antarabangsa

Standard e-mel moden menyokong alamat e-mel antarabangsa (EAI) dengan aksara bukan ASCII dalam bahagian tempatan dan domain. Walaupun sokongan EAI penuh mungkin tidak diperlukan untuk semua aplikasi, ketahuilah bahawa corak yang terhad kepada ASCII mungkin menolak alamat antarabangsa yang sah.

Pengesahan Sintaks E-mel dalam Konteks Berbeza

Tahap pengesahan format e-mel yang sesuai bergantung kepada kes penggunaan khusus anda dan toleransi risiko.

Borang Pendaftaran Pengguna

Untuk borang pendaftaran, utamakan pengalaman pengguna berbanding pengesahan ketat. Terima pelbagai alamat yang sah secara sintaksis dan bergantung pada e-mel pengesahan untuk mengesahkan kebolehsampai. Menolak alamat yang luar biasa tetapi sah mengecewakan pengguna dan mungkin merugikan pendaftaran anda.

Pengesahan Input API

API harus mengesahkan input untuk mencegah data yang jelas salah format daripada memasuki sistem anda. Corak pengesahan sederhana menangkap ralat awal sambil kekal cukup fleksibel untuk menerima alamat yang sah.

Senarai Pemasaran E-mel

Apabila memproses senarai e-mel yang diimport, gunakan pengesahan sintaks sebagai penapis pertama sebelum pemeriksaan pengesahan yang lebih mahal. Ini dengan cepat menghapuskan ralat pemformatan dan kesilapan taip yang jelas tidak boleh menerima e-mel.

Aplikasi Keselamatan Tinggi

Untuk aplikasi yang memerlukan jaminan tinggi kesahihan e-mel, pengesahan sintaks hanya berfungsi sebagai langkah pertama. Gabungkannya dengan pengesahan rekod MX, pengesahan SMTP, dan perkhidmatan pengesahan e-mel profesional seperti BillionVerify untuk pengesahan e-mel yang komprehensif.

Peranan Pengesahan Sintaks dalam Pengesahan E-mel

Pengesahan sintaks e-mel hanya mewakili satu lapisan dalam strategi pengesahan e-mel yang lengkap. Memahami bagaimana pengesahan sintaks sesuai dengan kaedah pengesahan lain membantu anda membina sistem pemeriksa e-mel yang berkesan.

Hierarki Pengesahan

Proses pengesahan e-mel yang komprehensif biasanya mengikut susunan ini:

1. Pengesahan Sintaks - Pemeriksaan format (fokus artikel ini)
2. Pengesahan Domain - Mengesahkan domain wujud
3. Semakan Rekod MX - Mengesahkan pelayan mel dikonfigurasikan
4. Pengesahan SMTP - Mengesahkan peti mel tertentu wujud
5. Penilaian Kebolehsampai - Memeriksa domain catch-all, alamat berasaskan peranan, e-mel pakai buang

Pengesahan sintaks gagal awal dan murah. Alamat yang tidak lulus semakan format asas tidak pernah meneruskan ke langkah pengesahan yang lebih mahal, menjimatkan sumber pengiraan dan panggilan API.

Menggabungkan dengan Perkhidmatan Profesional

Walaupun anda boleh melaksanakan pengesahan sintaks secara dalaman, perkhidmatan pengesahan e-mel profesional seperti BillionVerify mengendalikan saluran pengesahan lengkap. API BillionVerify melakukan pengesahan sintaks sebagai sebahagian daripada pengesahan e-mel komprehensifnya, menggabungkannya dengan pemeriksaan domain, pengesahan SMTP, pengesanan catch-all, dan pengenalan e-mel pakai buang dalam satu panggilan API.

async function verifyEmail(email) {
  // Semakan sintaks sebelah klien yang pantas
  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
    return { valid: false, reason: 'Invalid syntax' };
  }

  // Pengesahan penuh melalui API BillionVerify
  const response = await fetch('https://api.billionverify.com/v1/verify', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ email })
  });

  return await response.json();
}

Pendekatan ini menyediakan maklum balas segera untuk ralat sintaks yang jelas sambil mewakilkan pengesahan komprehensif kepada perkhidmatan pengesahan e-mel khusus.

Pertimbangan Prestasi

Prestasi regex pengesahan e-mel penting apabila memproses jumlah besar alamat atau melaksanakan pengesahan masa nyata.

Perbezaan Enjin Regex

Bahasa pengaturcaraan yang berbeza menggunakan enjin regex yang berbeza dengan ciri prestasi yang berbeza-beza. Uji corak anda dengan bahasa khusus anda dan persekitaran masa larian.

Backtracking Bencana

Corak regex yang kompleks dengan kuantifier bersarang boleh menyebabkan backtracking bencana, di mana enjin regex mengambil masa lebih lama secara eksponen pada input tertentu. Corak mudah dengan sempadan alternasi yang jelas mengelakkan masalah ini.

Kompil Sekali, Guna Berkali-kali

Jika mengesahkan banyak e-mel, kompilkan corak regex anda sekali dan gunakannya semula:

// Buruk: Kompil regex pada setiap panggilan
function validateMany(emails) {
  return emails.filter(email => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email));
}

// Baik: Kompil sekali
const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
function validateMany(emails) {
  return emails.filter(email => emailPattern.test(email));
}

Strategi Pengesahan Pukal

Untuk pengesahan e-mel pukal bagi senarai besar, proses alamat dalam kumpulan dengan pengesahan sintaks sebagai pra-penapis:

async function bulkVerify(emails) {
  const syntaxPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

  // Pra-tapis dengan pengesahan sintaks
  const syntaxValid = emails.filter(email =>
    syntaxPattern.test(email) && email.length <= 254
  );

  // Hantar hanya e-mel sah sintaks ke API
  const results = await emailVerifyBulkCheck(syntaxValid);

  // Gabungkan hasil dengan kegagalan sintaks
  return emails.map(email => {
    if (!syntaxPattern.test(email) || email.length > 254) {
      return { email, valid: false, reason: 'Invalid syntax' };
    }
    return results.find(r => r.email === email);
  });
}

Menguji Pengesah E-mel Anda

Pengujian menyeluruh memastikan pengesahan sintaks e-mel anda mengendalikan kes tepi dengan betul.

Kes Ujian untuk Alamat Sah

Pengesah anda harus menerima alamat sah ini:

simple@example.com
very.common@example.com
disposable.style.email.with+symbol@example.com
other.email-with-hyphen@example.com
fully-qualified-domain@example.com
user.name+tag+sorting@example.com
x@example.com
example-indeed@strange-example.com
example@s.example
user-@example.org
postmaster@[123.123.123.123]

Kes Ujian untuk Alamat Tidak Sah

Pengesah anda harus menolak alamat tidak sah ini:

Abc.example.com (tiada aksara @)
A@b@c@example.com (berbilang aksara @)
a"b(c)d,e:f;g<h>i[j\k]l@example.com (aksara khas tidak dalam petikan)
just"not"right@example.com (rentetan berpetikan mesti bersendirian)
this is"not\allowed@example.com (ruang dan petikan)
this\ still\"not\\allowed@example.com (garis belakang)
.user@example.com (titik utama)
user.@example.com (titik akhir)
user..name@example.com (titik berturut-turut)

Pengujian Automatik

Laksanakan ujian automatik untuk pengesah e-mel anda:

const validEmails = [
  'test@example.com',
  'user+tag@domain.org',
  'first.last@subdomain.example.co.uk',
  // Tambah lebih banyak kes ujian
];

const invalidEmails = [
  'not-an-email',
  'missing@tld',
  '@no-local-part.com',
  // Tambah lebih banyak kes ujian
];

describe('Email Syntax Validation', () => {
  validEmails.forEach(email => {
    it(`should accept ${email}`, () => {
      expect(validateEmail(email)).toBe(true);
    });
  });

  invalidEmails.forEach(email => {
    it(`should reject ${email}`, () => {
      expect(validateEmail(email)).toBe(false);
    });
  });
});

Pengalaman Pengguna Pengesahan Masa Nyata

Melaksanakan pengesahan sintaks e-mel dalam antara muka pengguna memerlukan pengimbangan maklum balas segera dengan pengalaman pengguna yang baik.

Masa Pengesahan

Jangan sahkan pada setiap ketukan kekunci—ini mencipta pengalaman yang janggal semasa pengguna menaip. Sebaliknya:

// Sahkan pada blur (apabila medan kehilangan fokus)
emailInput.addEventListener('blur', () => {
  validateAndShowFeedback(emailInput.value);
});

// Atau sahkan selepas pengguna berhenti menaip (debounced)
let timeout;
emailInput.addEventListener('input', () => {
  clearTimeout(timeout);
  timeout = setTimeout(() => {
    validateAndShowFeedback(emailInput.value);
  }, 500);
});

Kejelasan Mesej Ralat

Apabila pengesahan sintaks gagal, berikan panduan yang jelas:

function getValidationMessage(email) {
  if (!email.includes('@')) {
    return 'Sila sertakan simbol @ dalam alamat e-mel anda';
  }
  const [local, domain] = email.split('@');
  if (!domain) {
    return 'Sila masukkan domain selepas simbol @';
  }
  if (!domain.includes('.')) {
    return 'Sila masukkan domain yang sah (contohnya, example.com)';
  }
  if (email.length > 254) {
    return 'Alamat e-mel terlalu panjang';
  }
  return 'Sila masukkan alamat e-mel yang sah';
}

Maklum Balas Visual

Gabungkan pengesahan dengan maklum balas visual yang sesuai—warna, ikon, dan animasi yang menunjukkan keadaan sah atau tidak sah tanpa mengganggu.

Sokongan Alamat E-mel Antarabangsa

Aplikasi moden semakin perlu menyokong alamat e-mel antarabangsa yang mengandungi aksara bukan ASCII.

Standard EAI

Pengantarabangsaan Alamat E-mel (EAI) membenarkan:

• Aksara Unicode dalam bahagian tempatan
• Nama Domain Antarabangsa (IDN) dalam bahagian domain

Alamat seperti 用户@例子.中国 adalah sah di bawah standard EAI.

Pertimbangan Praktikal

Walaupun sokongan EAI berkembang, pertimbangkan faktor-faktor ini:

• Tidak semua pelayan mel menyokong EAI
• Banyak perkhidmatan pengesahan e-mel mungkin tidak menyokong sepenuhnya alamat antarabangsa
• Kaedah input pengguna untuk aksara bukan Latin berbeza-beza
• Penyimpanan dan perbandingan memerlukan normalisasi Unicode

Jika aplikasi anda menyasarkan pengguna antarabangsa, uji sokongan EAI dalam saluran pengesahan dan pengesahan e-mel anda.

Kesimpulan

Pengesahan sintaks e-mel berfungsi sebagai barisan pertahanan pertama yang penting dalam mana-mana sistem pengesahan e-mel. Walaupun tugas ini kelihatan mudah—memeriksa sama ada e-mel mengikut format yang betul—nuansa standard e-mel mencipta kerumitan yang mengejutkan.

Untuk kebanyakan aplikasi, pendekatan pragmatik berfungsi paling baik: gunakan corak regex yang munasabah yang menerima sebahagian besar alamat e-mel yang sah sambil menangkap ralat pemformatan yang jelas. Gabungkan ini dengan semakan panjang eksplisit dan, untuk pengesahan e-mel yang komprehensif, perkhidmatan profesional seperti BillionVerify yang mengendalikan pengesahan sintaks sebagai sebahagian daripada pengesahan e-mel lengkap termasuk pemeriksaan domain, pengesahan SMTP, dan penilaian kebolehsampai.

Ingat bahawa pengesahan sintaks sahaja tidak dapat mengesahkan bahawa alamat e-mel benar-benar wujud atau boleh menerima mesej. Ia hanya mengesahkan bahawa alamat mengikut format yang dijangkakan. Untuk pengesahan dan pengesahan e-mel sebenar, anda memerlukan saluran lengkap: pemeriksaan sintaks, pengesahan domain, pengesahan rekod MX, pengesahan SMTP, dan pemeriksaan khusus untuk domain catch-all, e-mel pakai buang, dan alamat berasaskan peranan.

Sama ada anda membina borang pendaftaran mudah atau platform pemasaran e-mel yang canggih, memahami pengesahan sintaks e-mel membantu anda membuat keputusan termaklum tentang tahap pemeriksaan yang sesuai untuk kes penggunaan anda. Mulakan dengan pengesahan munasabah yang mengutamakan pengalaman pengguna, dan bergantung pada perkhidmatan pengesahan e-mel komprehensif untuk pemeriksaan yang lebih mendalam yang tidak dapat disediakan oleh pengesahan sintaks.

Bina pengesah e-mel anda dengan ketepatan dan pengalaman pengguna dalam fikiran, uji dengan teliti dengan pelbagai alamat dunia sebenar, dan integrasikan dengan API pengesahan e-mel profesional seperti BillionVerify untuk keyakinan lengkap dalam kualiti data e-mel anda.

Untuk integrasi penuh, lihat panduan API pengesahan e-mel kami yang merangkumi perincian teknis dan contoh kod. Pengesahan sintaks adalah hanya langkah pertama—panduan kebolehsampai e-mel lengkap akan membantu anda memahami langkah pengesahan seterusnya selepas sintaks.