כיצד לאמת פרטי חשבון משתמש באמצעות ביטויים רגולריים

ביטויים רגולריים הם כלי תכנות אינטגרלי שבו אתה יכול להשתמש עבור הרבה משימות יומיומיות מעשיות. אתה יכול להשתמש בביטויים רגולריים כדי לחפש, להתאים או לנתח טקסט. עם הדפוסים הנכונים, אתה יכול לאמת כמה מפרטי חשבון המשתמש הנפוצים ביותר.

אתה יכול להשתמש בביטויים רגולריים עם שפות או כלים רבים, כולל Python ו-JavaScript.

Regex לאימות שם משתמש

שקול שם משתמש חוקי רק אם הוא עומד בתנאים הבאים:

1. מספר התווים חייב להיות בין 5 ל-15. (תוכל לציין טווח שונה בהתאם לדרישות שלך, אך בצע שינויים בביטוי הרגולרי בהתאם.)
2. המחרוזת צריכה להכיל רק תווים אלפאנומריים ו/או קווים תחתונים (_).
3. התו הראשון של המחרוזת צריך להיות אלפביתי.

הביטוי הרגולרי הבא עומד בתנאים שלעיל ויכול לאמת שם משתמש:

^[A-Za-z]\\w{4,14}$

אם אתה לא מרגיש בנוח עם הביטוי לעיל, בדוק מדריך למתחילים לביטויים רגולריים ראשון. זוהי גישת Python לאימות שם משתמש:

יְבוּא מִחָדָשׁ
defבדוק שם משתמש(שם משתמש):
 regex = "^[A-Za-z]\\w{4,14}$"
 r = re.compile (רגקס)
אם (מִחָדָשׁ.לחפש(ר, שם משתמש)):
 הדפס("תָקֵף")
אַחֵר:
 הדפס("לא בתוקף")
שם משתמש1 = "yuvraj_chandra"
checkUsername (שם משתמש1)
שם משתמש2 = "ja7&^%87"
checkUsername (שם משתמש2)

הפעלת קוד זה תאשר ששם המשתמש הראשון חוקי אך השני אינו:

באופן דומה, אתה יכול לאמת שם משתמש ב-JavaScript באמצעות הקוד הבא:

פוּנקצִיָהבדוק שם משתמש(מִשׁתַמֵשׁ) {
אם(/^[A-Za-z][A-Za-z0-9_]{4,14}$/.test (משתמש)) {
 console.log('תָקֵף');
 } אַחֵר {
 console.log('לא בתוקף');
 }
}
checkUsername('yuvraj_chandra');
checkUsername('ja7&^%87'); 

אתה יכול להשתמש בקוד זה כדי לאמת טפסי HTML באמצעות ביטויים רגולריים.

Regex לאימות כתובת אימייל

הביטוי הרגולרי לאימות כתובת אימייל אינו מושלם. אין ביטוי רגולרי מוסכם אוניברסלית כדי לאמת כתובת דוא"ל. זה לגמרי מסתכם בהגדרה שלך לתקף.

להלן רשימה של תנאים שיכולים לאמת את רוב כתובות האימייל:

1. שם המשתמש צריך להכיל רק תווים אלפאנומריים, קו תחתון, מקף ו/או נקודה.
2. מחרוזת מזהה הדוא"ל חייבת לכלול תו @ אחד.
3. שם הדומיין צריך להכיל רק תווים אלפאנומריים, קו תחתון או מקף.
4. חייבת להיות נקודה אחרי שם הדומיין.
5. סיומת הדומיין צריכה להכיל רק תווים אלפאנומריים, קו תחתון או מקף.
6. אורך סיומת הדומיין צריך להיות בין 2 ל-4.

הביטוי הרגולרי הבא עומד בתנאים שלעיל ויכול לאמת כתובת דוא"ל:

^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$

זוהי גישת Python לאימות כתובת דואר אלקטרוני:

יְבוּא מִחָדָשׁ
defcheckEmailId(אימייל):
 regex = "^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$"
 r = re.compile (רגקס)
אם (מִחָדָשׁ.לחפש(ר, אימייל)):
 הדפס("תָקֵף")
אַחֵר:
 הדפס("לא בתוקף")
אימייל1 = "[email protected]"
checkEmailId (email1)
email2 = "abc@def@gmail.kahscg"
checkEmailId (email2)

שוב, הפלט מאשר שכתובת האימייל הראשונה תקפה ואילו השנייה לא חוקית:

אתה יכול לאמת אימייל ב-JavaScript באמצעות הקוד הבא:

פוּנקצִיָהcheckEmailId(אימייל) {
אם (/^[\w.-]+@([\w-]+\.)+[\w-]{2,4}$/.test (אימייל)) {
לְנַחֵם.log('תקף');
 } אַחֵר {
לְנַחֵם.log('לא חוקי');
 }
}
checkEmailId("[email protected]");
checkEmailId("abc@[email protected]");

בדוק את עוצמת הסיסמה באמצעות ביטויים רגולריים

סיסמאות חזקות חיוניות מנקודת מבט אבטחה. עליך לוודא שלמשתמשי הקצה יש סיסמאות חזקות מספיק כדי שאחרים לא יוכלו לגשת לחשבונות שלהם.

הכללים הבאים מוודאים שעוצמת הסיסמה של האפליקציה שלך חזקה:

1. המספר המינימלי של תווים חייב להיות 8.
2. המחרוזת חייבת להיות לפחות ספרה אחת.
3. המחרוזת חייבת להיות בעלת תו גדול אחד לפחות.
4. המחרוזת חייבת להיות בעלת תו קטן אחד לפחות.
5. המחרוזת חייבת להיות בעלת תו מיוחד אחד לפחות.

הביטוי הרגולרי הבא עומד בתנאים שלעיל ויכול לעזור להבטיח סיסמה חזקה יותר:

(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{ 8,})

אתה יכול לבדוק את חוזק הסיסמה ב- Python באמצעות הקוד הבא:

יְבוּא מִחָדָשׁ
defcheckPassword Strength(סיסמה):
 regex = "(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{ 8,})"
 r = re.compile (רגקס)
אם (מִחָדָשׁ.לחפש(ר, סיסמה)):
 הדפס("סיסמא חזקה")
אַחֵר:
 הדפס("ססמה חלשה")
סיסמה1 = "Hiuahd $5jawd"
checkPassword Strength (סיסמה1)
סיסמה2 = "הסיסמא שלי"
checkPasswordStrength (סיסמה2)

הפעלת קוד זה תאשר שהסיסמה הראשונה חזקה ואילו השנייה חלשה:

אתה יכול לבדוק את עוצמת הסיסמה ב-JavaScript באמצעות הקוד הבא:

פוּנקצִיָהcheckPassword Strength(סיסמה) {
אם (/(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[^A-Za-z0-9])(?=.{8,})/.test (סיסמה)) {
 console.log('סיסמא חזקה');
 } אַחֵר {
 console.log('ססמה חלשה');
 }
}
checkPasswordStrength('Hiuahd $5jawd');
checkPasswordStrength('הסיסמא שלי');

ביטוי רגיל כדי להתאים לתאריך תקף

אם אתה רוצה לבדוק במהירות אם התאריכים הנתונים הם בפורמט התאריך המסורתי או לא, אתה יכול לעשות זאת באמצעות ביטוי רגיל.

הביטוי הרגולרי הבא תואם תאריך ב mm/dd/yyyy פוּרמָט:

^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20 )\d\d$

קוד Python הבא מאמת את התאריך שבו mm/dd/yyyy פוּרמָט:

יְבוּא מִחָדָשׁ
defcheckDateFormat(תַאֲרִיך):
 regex = "^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19|20 )\d\d$"
 r = re.compile (רגקס)
אם(מִחָדָשׁ.לחפש(ר, תַאֲרִיך)):
 הדפס("תָקֵף")
אַחֵר:
 הדפס("לא בתוקף")
תאריך1 = "03/21/2002"
checkDateFormat (תאריך1)
תאריך2 = "15/21/2002"
checkDateFormat (תאריך2)

פעם נוספת, הפלט מאשר שפורמט התאריך הראשון תקין, אך השני אינו חוקי:

אתה יכול לאמת את התאריך ב mm/dd/yyyy פורמט ב-JavaScript באמצעות הקוד הבא:

פוּנקצִיָהcheckDateFormat(תַאֲרִיך) {
אם(/^(0[1-9]|1[012])[- /.](0[1-9]|[12][0-9]|3[01])[- /.](19| 20)\d\d$/.תאריך מבחן)) {
 console.log('תָקֵף');
 } אַחֵר {
 console.log('לא בתוקף');
 }
}
checkDateFormat('03/21/2002');
checkDateFormat('15/21/2002');

אימות מחרוזת ריקה באמצעות ביטויים רגולריים

אתה יכול לבדוק אם מחרוזת ריקה באמצעות הביטוי הרגולרי הבא:

^$

להלן גישת Python לאימות מחרוזת ריקה:

יְבוּא מִחָדָשׁ
defcheckEmptyString(str):
 regex = "^$"
 r = re.compile (רגקס)
אם (מִחָדָשׁ.לחפש(ר, str)):
הדפס("המחרוזת הנתונה היא ריק")
אַחֵר:
הדפס("המחרוזת הנתונה אינה ריק")
str1 = ""
checkEmptyString (str1)
str2 = "זו אינה מחרוזת ריקה"
checkEmptyString (str2)

הפלט הבא מדגים שהמחרוזת הנתונה הראשונה ריקה ואילו השנייה לא:

השתמש בקוד JavaScript הבא כדי לבדוק אם המחרוזת ריקה או לא:

פוּנקצִיָהcheckEmptyString(str) {
אם (/^$/.test (str)) {
 console.log('המחרוזת הנתונה ריקה');
 } אַחֵר {
 console.log('המחרוזת הנתונה אינה ריקה');
 }
}
checkEmptyString('');
checkEmptyString('זו אינה מחרוזת ריקה'); 

RegEx לאימות מיקוד (מיקוד בארה"ב)

אתה יכול לאמת מיקוד (מיקוד ארה"ב) בפורמט של חמש ספרות ותשע ספרות (הנקרא ZIP+4) באמצעות הביטוי הרגולרי הבא:

^[0-9]{5}(?:-[0-9]{4})?$

להלן קוד Python לאימות מיקוד:

יְבוּא מִחָדָשׁ
defvalidateZIPCode(קוד):
 regex = "^[0-9]{5}(?:-[0-9]{4})?$"
 r = re.compile (רגקס)
אם (מִחָדָשׁ.לחפש(ר, קוד)):
 הדפס("תָקֵף")
אַחֵר:
 הדפס("לא בתוקף")
קוד1 = "76309"
validateZIPCode (קוד1)
קוד2 = "83468-2348"
validateZIPCode (קוד2)
קוד3 = "234445"
validateZIPCode (קוד3)

הפעלת קוד זה תאשר שהמיקוד הראשון והשני תקפים אך השלישי אינו:

השתמש בקוד JavaScript הבא כדי לאמת את המיקוד באמצעות ביטוי רגיל:

פוּנקצִיָהvalidateZIPCode(קוד) {
אם (/^[0-9]{5}(?:-[0-9]{4})?$/.test (קוד)) {
 console.log('תָקֵף');
 } אַחֵר {
 console.log('לא בתוקף');
 }
}
validateZIPCode('76309');
validateZIPCode('83468-2348');
validateZIPCode('234445');

אמת את קלט המשתמש באמצעות קוד חזק

למדת כיצד לאמת פרטי חשבון משתמש באמצעות ביטויים רגולריים. אימות הפרטים הללו הופך את הקוד לחזק ועוזר להתמודד עם בעיות אבטחה ובאגים לא רצויים. קוד חזק מספק חוויה בטוחה ומאובטחת למשתמשים שלך.

עליך לוודא שאתה מאמת את נתוני הקלט או בצד הלקוח או בצד השרת כדי להיות תמיד על הצד הבטוח מהאקרים.