דילוג לתוכן

Barcode Scanner Emulator

איך לבדוק קלט של סורק QR ביישומי אינטרנט

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

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

בדיקת קלט של סורק QR ב-60 שניות

השתמשו במטען שבחרתם, כדי שתו שגוי יהיה ברור. ההדגמה הזו משתמשת ב-QR-INPUT-TEST-12345.

  1. פתחו את מחולל קודי QR וצרו קוד QR עבור QR-INPUT-TEST-12345. המחולל רץ בדפדפן. הוא לא יוצר קשר עם הסורק.
  2. חברו סורק שתומך ב-QR ומוגדר למצב טריז מקלדת. סורק של 1D בלבד לא יכול לפענח את הסמל הזה.
  3. פתחו את בודק קלט ברקוד.
  4. לחצו על התחילו בדיקה, או לחצו על אזור הסריקה, כדי שלשדה יהיה מיקוד. הבודק לא לוקח מיקוד בעצמו, והוא לא פותח את הסורק.
  5. סרקו את קוד ה-QR.
  6. קראו את הטקסט שנלכד ואת מספר התווים.
  7. השוו את הטקסט הזה ל-QR-INPUT-TEST-12345. ההתאמה כוללת רישיות, מקפים ואורך.
  8. קראו את הסיומת. הבודק מדווח ENTER, TAB או ללא כשהסורק שולח אחד מהמקשים האלה.

הבודק רושם אירועי מקלדת שהדפדפן יכול לראות. הוא לא מזהה את התקן ה-USB, לא קורא יציאה טורית, ולא מפענח את תמונת ה-QR.

מצבי קלט של סורק QR

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

סורקי QR בטריז מקלדת

במצב מקלדת USB HID, או במצב מקלדת Bluetooth HID, מערכת ההפעלה מתייחסת לסורק כמקלדת. אחרי פענוח הסורק מקליד את המטען לפקד שיש לו מיקוד. <input> או <textarea> רגילים יכולים לקבל אותו. העמוד לא פותח את המכשיר. המדריך טריז מקלדת HID מוסבר מתאר את רצף ההקשות, את הקידומות ואת הסיומות.

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

סורקי QR טוריים

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

דפדפנים מבוססי Chromium יכולים לפתוח יציאה שהמשתמש בחר באמצעות Web Serial API, בהקשר מאובטח, אחרי מחווה של המשתמש. Firefox ו-Safari לא מספקים את ה-API הזה. סורק טריז לא מופיע כיציאה טורית. שמות יציאות, קצב בוד ומיסגור תלויים במכשיר ובמנהל ההתקן. סורקי ברקוד USB HID מול טורי משווה את שני הממשקים. בודק קלט ברקוד לא יכול לקרוא יציאת COM.

סריקת QR מבוססת מצלמה

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

לכידת קלט של סורק QR עם JavaScript

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

הדוגמה מקבלת שלוש תבניות יישום: מזהה כרטיס כמו QR-INPUT-TEST-12345, כתובת http או https, או אובייקט JSON. היא רושמת את הטקסט שנסרק. היא לא מנווטת לכתובת שנמצאה בקוד ה-QR. סורק שלא שולח Enter עדיין עובד דרך הלחצן. Tab עובר על התווית, השדה והלחצן כרגיל, כי הסקריפט לא לוכד אותו.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>QR input example</title>
</head>
<body>
  <form id="qr-form">
    <label for="qr">QR payload</label>
    <input id="qr" name="qr" type="text" autocomplete="off" spellcheck="false">
    <button type="submit">Accept</button>
  </form>
  <p id="status" role="status"></p>
  <pre id="captured"></pre>
  <script>
    const form = document.querySelector('#qr-form')
    const field = document.querySelector('#qr')
    const status = document.querySelector('#status')
    const captured = document.querySelector('#captured')

    if (
      !(form instanceof HTMLFormElement) ||
      !(field instanceof HTMLInputElement) ||
      !(status instanceof HTMLElement) ||
      !(captured instanceof HTMLElement)
    ) {
      throw new Error('QR form markup is missing.')
    }

    const accepted = new Set()

    function classify(raw) {
      if (/[\u0000-\u001F\u007F]/.test(raw)) {
        return { status: 'invalid', message: 'Control character in the QR payload.' }
      }

      const value = raw.trim()
      if (!value) {
        return { status: 'empty' }
      }
      if (value.length > 2048) {
        return { status: 'invalid', message: 'QR payload is longer than this form accepts.' }
      }
      if (/^QR-[A-Z0-9-]{1,64}$/.test(value)) {
        return { status: 'ok', value }
      }
      if (value.startsWith('{')) {
        try {
          const data = JSON.parse(value)
          if (!data || typeof data !== 'object' || Array.isArray(data)) {
            return { status: 'invalid', message: 'QR JSON must be an object.' }
          }
          return { status: 'ok', value }
        } catch {
          return { status: 'invalid', message: 'QR text is not valid JSON.' }
        }
      }
      if (value.startsWith('http://') || value.startsWith('https://')) {
        try {
          const url = new URL(value)
          if (url.protocol !== 'http:' && url.protocol !== 'https:') {
            return { status: 'invalid', message: 'Only http and https URLs are accepted.' }
          }
          return { status: 'ok', value }
        } catch {
          return { status: 'invalid', message: 'The QR text is not a valid URL.' }
        }
      }
      return { status: 'invalid', message: 'Unexpected QR payload.' }
    }

    form.addEventListener('submit', (event) => {
      event.preventDefault()
      const outcome = classify(field.value)
      if (outcome.status === 'empty') {
        status.textContent = 'No QR payload received.'
        field.focus()
        return
      }
      if (outcome.status === 'invalid') {
        status.textContent = outcome.message
        captured.textContent = ''
        field.focus()
        return
      }
      if (accepted.has(outcome.value)) {
        status.textContent = 'Already accepted ' + outcome.value
        field.value = ''
        field.focus()
        return
      }
      accepted.add(outcome.value)
      captured.textContent = outcome.value
      status.textContent = 'Accepted ' + outcome.value
      field.value = ''
      field.focus()
    })
  </script>
</body>
</html>

שמרו את הקובץ ופתחו אותו בדפדפן שולחני. לחצו על השדה לפני הסריקה. autocomplete="off" מקטין את הסיכוי שערך שמור יחליף את הסריקה. התווית והלחצן נשארים זמינים, כך שאדם יכול להקליד מטען בלי סורק.

טפלו ב-Enter רק באירוע submit של הטופס. מאזין keydown שני ל-Enter רושם את אותה סריקה פעמיים. preventDefault() משאיר את הדפדפן בעמוד הזה. נקו את השדה אחרי החלטה כדי שהסריקה הבאה לא תתווסף לטקסט הקודם.

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

טיפול במטעני QR

סמל QR לא מבטיח תבנית יישום. אותה סימבולוגיה יכולה לשאת כל אחד מאלה:

  • טקסט פשוט, כמו QR-INPUT-TEST-12345.
  • כתובת URL.
  • מזהה שהיישום בחר.
  • מטען מובנה, כמו מספר כרטיס יחד עם קוד מיקום.
  • טקסט JSON, כשהיישום הגדיר את הקידוד הזה.

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

אימות קלט QR

אל תניחו שמטען QR הוא מספרי. כללי EAN-13 לא חלים. התייחסו לטקסט כלא מהימן: הציגו אותו כטקסט, ואל תשייכו אותו ל-location, ל-innerHTML או לכתובת של סקריפט.

ערכים ריקים. Enter חשוף, או Accept על שדה ריק, לא אמור ליצור רשומה. trim() גם דוחה מטען שהוא רק רווחים.

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

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

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

function isTicketId(value) {
  return /^QR-[A-Z0-9-]{1,64}$/.test(value)
}

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

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

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

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

function readJsonObject(value) {
  try {
    const data = JSON.parse(value)
    if (!data || typeof data !== 'object' || Array.isArray(data)) {
      return { ok: false, message: 'QR JSON must be an object.' }
    }
    return { ok: true, data }
  } catch {
    return { ok: false, message: 'QR text is not valid JSON.' }
  }
}

כתובות לא צפויות. נתחו את הכתובת כדי לראות אם היא שמישה, ואז שמרו את המחרוזת שנסרקה אם הבדיקה חייבת להתאים למטען ה-QR בדיוק. URL.href יכול להוסיף לוכסן או לשנות קידוד. קבלו רק את הסכמות שהיישום מתכוון אליהן. אל תפתחו את הכתובת כתופעת לוואי של הסריקה:

function readWebUrl(value) {
  let url
  try {
    url = new URL(value)
  } catch {
    return { ok: false, message: 'The QR text is not a valid URL.' }
  }
  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
    return { ok: false, message: 'Only http and https URLs are accepted.' }
  }
  return { ok: true, value }
}

תווי בקרה. דחו תווי בקרה של ASCII במטען מקלדת כדי שקידומת נסתרת תישאר גלויה בטקסט הסטטוס. CR ו-LF הם תווי בקרה. בסורק טריז, Enter ו-Tab הם מקשים. הם לא תווים בתוך קלט טקסט רגיל. מטען טורי עדיין יכול להכיל בתים 0x0D או 0x0A. הסירו אותם בגבול המיסגור הטורי, ואל תסירו CR ששייך לאמצע של מטען מרובה שורות.

סיומות ENTER ו-TAB

סיומת היא הגדרה אופציונלית של הסורק. היא לא חלק מסמל ה-QR. סיומות ENTER מול TAB בסורקי ברקוד מראה איך להבדיל בין המקשים. קראו את הסיומת בבודק הקלט, ואז התאימו את העמוד לסורקים שאתם פורסים.

ENTER שולח את הטופס של שדה טקסט בן שורה אחת בדפדפנים הנוכחיים. השתמשו בזה כשסריקה אחת צריכה לאשר את הערך. קראו ל-preventDefault() על submit כשהעמוד צריך להישאר במקום.

TAB מעביר את המיקוד לפקד הבא. קראו את הערך ב-keydown בזמן שלשדה עדיין יש מיקוד. השאירו את פעולת ברירת המחדל כשהשדה הבא צריך לקבל מיקוד. התעלמו מ-Shift+Tab כדי שמשתמש מקלדת יוכל לנוע אחורה.

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

CR ו-LF הם בתים. Enter של מקלדת הוא event.key === "Enter". אלה לא חליפיים. מאזין שמסיר רק \r מערך קלט לא יראה Enter של טריז, כי התו מעולם לא הוכנס. מאזין שצופה רק ב-event.key לא יפצל מאגר טורי על 0x0D. חלק מהמכשירים שולחים NumPad Enter. event.key עדיין "Enter". בדקו את event.key, לא רק את event.code === "Enter".

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

ניפוי אירועי מקלדת

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

keydown. נורה לכל מקש, כולל Enter ו-Tab, לפני שהדפדפן מכניס תו או מזיז מיקוד. קראו את המסיים כאן.

input. נורה אחרי שתו בר הדפסה משנה את השדה. הוא לא נורה עבור Enter או Tab בקלט טקסט.

event.key. התו או שם המקש אחרי שמערכת ההפעלה מפעילה את פריסת המקלדת.

event.code. המקש הפיזי, כמו Digit1 או Numpad1. הוא יכול להישאר זהה כשאי-התאמת פריסה משנה את event.key.

מיקוד. רשמו את document.activeElement לפני הסריקה. אם זה לא שדה ה-QR, שאר המעקב מתאר את הפקד הלא נכון. ל-iframe יש מיקוד משלו.

סדר. בסריקת טריז לתוך שדה טקסט, אירועי keydown ברי הדפסה באים ואחריהם עדכוני input, ואז keydown אחרון ל-Enter או ל-Tab כשהסיומת הזו מוגדרת. change נורה כשהשדה מתחייב, בדרך כלל במעבר ללא מיקוד. סריקה שמשאירה את המיקוד באותו שדה לא מייצרת change בסוף. אל תשתמשו ב-change כאות ההשלמה היחיד.

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

בודק אירועי מקלדת מפרט כל keydown ו-keyup עם key, code, מקשי שינוי וחותמות זמן. היומן הוא אירועי דפדפן. הוא לא תעבורת USB גולמית.

בדיקה בלי סורק QR פיזי

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

  • הקלידו QR-INPUT-TEST-12345 בשדה והפעילו את Accept. זה בודק אימות ותצוגה. זה לא בודק פענוח או סיומות.
  • הניעו את אותו שדה מכלי אוטומציה של הדפדפן, כמו שהסעיף הבא עושה.
  • השתמשו ב-Barcode Scanner Emulator כשצריך הקלדה בסגנון סורק. יישום שולחני שולח ערך שאתם מזינים, עם השהיית הקלדה וסיומת של ללא, ENTER או TAB, ליישום הממוקד. הוא משחזר את נתיב המקלדת. הוא לא מצלם תמונת QR, לא מפענח סמל, ולא יוצר יציאת COM וירטואלית.

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

אוטומציה של בדיקות קלט QR

בדיקות Playwright הבאות מניעות את עמוד הדוגמה. הן מקלידות לשדה כמו שסורק טריז היה עושה, ואז מאשרות את התנהגות היישום. הן לא פותחות התקני USB. @playwright/test היא תלות של הקורא. האתר הזה לא דורש אותה.

שמרו את דוגמת ה-HTML בשם qr-form.html ליד הבדיקה הזו.

import { readFileSync } from 'node:fs'
import { expect, test } from '@playwright/test'

const html = readFileSync(new URL('./qr-form.html', import.meta.url), 'utf8')

async function openForm(page) {
  await page.setContent(html)
}

test('accepts a known QR payload once', async ({ page }) => {
  await openForm(page)
  const field = page.getByLabel('QR payload')
  await field.pressSequentially('QR-INPUT-TEST-12345')
  await field.press('Enter')
  await expect(page.getByRole('status')).toHaveText('Accepted QR-INPUT-TEST-12345')
  await expect(page.locator('#captured')).toHaveText('QR-INPUT-TEST-12345')
})

test('rejects an unexpected payload', async ({ page }) => {
  await openForm(page)
  const field = page.getByLabel('QR payload')
  await field.pressSequentially('not-a-ticket')
  await field.press('Enter')
  await expect(page.getByRole('status')).toHaveText('Unexpected QR payload.')
  await expect(page.locator('#captured')).toBeEmpty()
})

test('commits on ENTER and rejects a duplicate scan', async ({ page }) => {
  await openForm(page)
  const field = page.getByLabel('QR payload')
  await field.pressSequentially('QR-INPUT-TEST-12345')
  await field.press('Enter')
  await field.pressSequentially('QR-INPUT-TEST-12345')
  await field.press('Enter')
  await expect(page.getByRole('status')).toHaveText('Already accepted QR-INPUT-TEST-12345')
  await expect(page.locator('#captured')).toHaveText('QR-INPUT-TEST-12345')
})

test('does not capture keys while the field is unfocused', async ({ page }) => {
  await openForm(page)
  await page.getByRole('button', { name: 'Accept' }).focus()
  await page.keyboard.type('QR-INPUT-TEST-12345')
  await expect(page.getByLabel('QR payload')).toHaveValue('')
  await expect(page.locator('#captured')).toBeEmpty()
  await expect(page.getByRole('status')).toHaveText('')
})

test('shows unexpected characters as text', async ({ page }) => {
  await openForm(page)
  const payload = '<img src=x onerror=alert(1)>'
  const field = page.getByLabel('QR payload')
  await field.fill(payload)
  await page.getByRole('button', { name: 'Accept' }).click()
  await expect(page.getByRole('status')).toHaveText('Unexpected QR payload.')
  await expect(page.locator('#captured img')).toHaveCount(0)
  await expect(page.locator('img')).toHaveCount(0)
})

pressSequentially מכניס תווים לשדה הממוקד. זה לא התקן USB. בדיקת התווים הלא צפויים משתמשת ב-fill כי המטרה היא הודעת האימות והיעדר רכיב מוזרק. הרחיבו את הקובץ במקרה URL ובמקרה JSON כשהתבניות האלה נמצאות בגרסה שאתם משחררים. אישור URL צריך להשוות את הטקסט שנלכד למחרוזת ה-QR המקורית.

מטריצת בדיקות של סורק QR

הריצו אותן מול היישום שבבדיקה. עמוד הדוגמה למעלה מכסה את שורות הכרטיס, ה-URL, ה-JSON, הכפילות, הערך הריק והתווים הלא צפויים. יישום מספרי בלבד או מרובה שורות צריך תוצאה צפויה משלו.

תרחיש תוצאה צפויה
QR בטקסט פשוט התקבל ערך מדויק
QR של URL נלכדה כתובת מלאה, והעמוד לא מנווט אליה
QR מספרי הספרות נשמרו
תווים מיוחדים התקבלו התווים הנכונים
מטען JSON הנתונים נלכדו ואומתו
סיומת ENTER העיבוד מתרחש פעם אחת
סיומת TAB התנהגות המיקוד מטופלת
בלי סיומת היישום משתמש במנגנון השלמה חלופי
סריקה כפולה היישום מחיל כללי טיפול בכפילויות
מטען לא תקין מוצגת שגיאת אימות
מיקוד חסר היישום מטפל בקלט נעדר בבטחה
מטען ארוך אין קיטוע לא מכוון

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

פתרון בעיות

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

הסורק מצפצף אבל לא מופיע קלט

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

סורק QR עובד ב-Notepad אבל לא בדפדפן

המכשיר מקליד. העמוד לא מקבל את המקשים האלה. בדקו מיקוד, מאזין keydown שקורא ל-preventDefault() על מקשים ברי הדפסה, ומאזין שמטפל רק ב-paste. קלט טריז לא מפעיל אירוע paste. השוו את תוצאת הבודק לשדה היישום.

הסורק קורא ברקודים אבל לא קודי QR

המכשיר עשוי להיות של 1D בלבד, או שסימבולוגיית QR עשויה להיות כבויה. העמוד לא יכול לתקן את זה. אשרו תמיכה ב-2D והפעילו QR Code ממדריך המכשיר, באמצעות הבדיקות בבדיקת קוד QR: איך לבדוק סורקי QR. סריקת Code 128 מוצלחת מוכיחה רק את נתיב המקלדת.

תווים שגויים

סרקו קודם את QR-INPUT-TEST-12345. אם זה תואם ומטען URL או JSON לא, הפריסה משנה פיסוק כמו :, /, { או ". השוו את event.key ל-event.code בבודק אירועי מקלדת, וראו פריסת מקלדת שגויה בסורק ברקוד. התאימו את פריסת המקלדת של הסורק למערכת ההפעלה.

ENTER שולח את הטופס פעמיים

הדפדפן שולח את הטופס, ומאזין keydown גם מטפל ב-Enter. השאירו נתיב השלמה אחד וקראו שם ל-preventDefault(). סריקה פיזית שנייה היא כשל אחר. טקסט הסטטוס בדוגמה אומר שהמטען כבר התקבל. אם הסריקה הראשונה עצמה יוצרת שתי רשומות, חפשו שני מאזינים לפני שמשנים את הסורק.

קלט QR נחתך

השוו את מספר התווים בבודק הקלט לערך בשדה. מאפיין maxlength, מסכת קלט, או preventDefault() על מקשי תווים יכולים לחתוך את המחרוזת. שורה חדשה בתוך מטען ה-QR יכולה לשלוח קלט של שורה אחת מוקדם מדי. חלק מהסורקים גם מגבילים כמה תווים הם מקלידים. העלו את הגבול הזה ממדריך המכשיר כשהבודק, לא רק היישום, מציג ערך קצר. לסורק הברקוד חסר ENTER מכסה את המקרה הקרוב, שבו המטען מגיע והטופס אף פעם לא מתחייב.

הסורק לא יכול לקרוא קוד QR על המסך

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