Sari la conținut

Barcode Scanner Emulator

Cum se testează introducerea de la scanerul de coduri QR în aplicațiile web

Multe scanere externe capabile de QR folosesc modul pană de tastatură și tastează textul QR decodificat în câmpul focalizat. Testați acea cale scanând un conținut cunoscut și comparându-l cu valoarea pe care a primit-o pagina. Nu orice scaner QR tastează ca o tastatură. Dispozitivele seriale și decodoarele de cameră sunt integrări diferite, iar evenimentele de tastatură din browser nu identifică scanerul fizic.

Un cod QR stochează date. Scanerul, sau un decodor de cameră, transformă acele date în text. Aplicația web trebuie apoi să primească textul, să decidă când s-a terminat scanarea și să îl valideze. Acest ghid este acel test al aplicației. Generarea etichetelor, verificarea contrastului și confirmarea că un dispozitiv poate decoda QR Code sunt tratate în Testarea codurilor QR: cum se testează scanerele de coduri QR. Formularele generale de coduri de bare, inclusiv cifrele de control EAN, sunt tratate în Cum se testează scanerele de coduri de bare în aplicațiile web.

Testați introducerea de la scanerul QR în 60 de secunde

Folosiți un conținut pe care l-ați ales, ca un caracter greșit să fie evident. Acest parcurs folosește QR-INPUT-TEST-12345.

  1. Deschideți generatorul de coduri QR și generați un cod QR pentru QR-INPUT-TEST-12345. Generatorul rulează în browser. Nu contactează scanerul.
  2. Conectați un scaner capabil de QR setat pe modul pană de tastatură. Un scaner doar 1D nu poate decoda acest simbol.
  3. Deschideți testerul de introducere a codurilor de bare.
  4. Faceți clic pe Pornește testul sau faceți clic pe zona de scanare, ca câmpul să aibă focalizarea. Testerul nu preia focalizarea singur și nu deschide scanerul.
  5. Scanați codul QR.
  6. Citiți textul capturat și numărul de caractere.
  7. Comparați acel text cu QR-INPUT-TEST-12345. Potrivirea include literele mari și mici, cratimele și lungimea.
  8. Citiți sufixul. Testerul raportează ENTER, TAB sau Niciunul când scanerul trimite una dintre acele taste.

Testerul înregistrează evenimentele de tastatură pe care browserul le poate vedea. Nu identifică dispozitivul USB, nu citește un port serial și nu decodează imaginea QR.

Moduri de introducere de la scanerul QR

Același cod QR tipărit poate sosi prin trei integrări diferite. Un test al unui mod nu le exersează pe celelalte.

Scanere QR cu pană de tastatură

În modul tastatură USB HID, sau în modul tastatură Bluetooth HID, sistemul de operare tratează scanerul ca pe o tastatură. După o decodare, scanerul tastează conținutul în controlul care are focalizarea. Un <input> sau un <textarea> obișnuit îl poate primi. Pagina nu deschide dispozitivul. Ghidul Pană de tastatură HID descrie succesiunea apăsărilor, prefixele și sufixele.

Focalizarea decide destinația. Dacă elementul focalizat este corpul documentului, un buton sau un alt cadru, ascultătorii acestui câmp nu văd scanarea.

Scanere QR seriale

Un scaner serial USB sau cu port COM virtual trimite textul decodificat ca octeți către procesul care a deschis portul. Focalizarea nu alege acel proces. Un câmp care ascultă doar apăsări rămâne gol, în timp ce un terminal de pe acel port arată conținutul.

Browserele bazate pe Chromium pot deschide un port ales de utilizator cu Web Serial API, într-un context securizat, după un gest al utilizatorului. Firefox și Safari nu oferă acel API. Un scaner pană nu apare ca port serial. Numele porturilor, baudul și încadrarea depind de dispozitiv și de driver. Scanere de coduri de bare USB HID și seriale compară cele două interfețe. Testerul de introducere a codurilor de bare nu poate citi un port COM.

Scanare QR cu cameră

O integrare cu cameră capturează o imagine și decodează codul QR în software. Pagina folosește un API de cameră și un decodor. Nu primește evenimente keydown pentru conținut. Aplicațiile de cameră ale telefonului, butoanele de cameră din pagină și un imager hardware care tastează într-un câmp sunt trei produse diferite. Trecerea unui test de pană nu înseamnă că butonul de cameră funcționează, iar o decodare reușită cu camera nu înseamnă că un scaner pană va tasta același șir.

Capturați introducerea de la scanerul QR cu JavaScript

Pagina de mai jos citește un singur câmp focalizat. Enter trimite formularul, iar butonul Accept folosește același handler de submit, așa că o scanare este prelucrată o dată. Fără un sufix ENTER, textul rămâne în câmp până când cineva activează Accept. Conținutul capturat este scris cu textContent, așa că caractere precum < rămân vizibile ca text.

Exemplul acceptă trei formate de aplicație: un id de bilet cum este QR-INPUT-TEST-12345, un URL http sau https, sau un obiect JSON. Înregistrează textul scanat. Nu navighează la un URL găsit în codul QR. Un scaner care nu trimite Enter funcționează în continuare prin buton. Tab trece prin etichetă, câmp și buton ca de obicei, pentru că scriptul nu îl prinde.

<!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>

Salvați fișierul și deschideți-l într-un browser de desktop. Faceți clic pe câmp înainte de scanare. autocomplete="off" reduce șansa ca o valoare salvată să înlocuiască scanarea. Eticheta și butonul rămân disponibile, așa că o persoană poate tasta un conținut fără scaner.

Tratați Enter doar în evenimentul submit al formularului. Un al doilea ascultător keydown pentru Enter înregistrează aceeași scanare de două ori. preventDefault() ține browserul pe această pagină. Goliți câmpul după o decizie, ca scanarea următoare să nu se adauge la textul anterior.

Un conținut QR poate conține un sfârșit de linie. Un scaner pană tastează adesea acea întrerupere ca Enter. Într-un input pe un rând, formularul se poate trimite la primul rând și poate pierde restul. Folosiți un textarea, sau o citire serială care păstrează octeții, când aplicația trebuie să accepte text pe mai multe rânduri. Confirmați acel comportament cu un cod QR al cărui conținut include un rând nou.

Tratarea conținutului QR

Un simbol QR nu promite un format de aplicație. Aceeași simbologie poate purta oricare dintre acestea:

  • Text simplu, cum este QR-INPUT-TEST-12345.
  • Un URL.
  • Un identificator ales de aplicație.
  • Un conținut structurat, cum este un număr de bilet plus un cod de locație.
  • Text JSON, când aplicația a definit acea codare.

Scanerul transmite caracterele decodate. Nu verifică dacă se potrivesc cu o regulă de bilet, un catalog de produse sau o schemă JSON. Validați șirul în pagină și validați-l din nou pe server. Valoarea trimisă este introducere obișnuită de utilizator. Browserul nu poate dovedi că a produs-o un scaner.

Validați introducerea QR

Nu presupuneți că un conținut QR este numeric. Regulile EAN-13 nu se aplică. Tratați textul ca nefiind de încredere: afișați-l ca text și nu îl atribuiți lui location, innerHTML sau unui URL de script.

Valori goale. Un Enter simplu, sau Accept pe un câmp gol, nu ar trebui să creeze o înregistrare. trim() respinge și un conținut format doar din spații.

Caractere neașteptate. Comparați șirul primit cu conținutul QR cunoscut. O nepotrivire de dispunere a tastaturii schimbă adesea punctuația, în timp ce lungimea rămâne aceeași. Respingeți caracterele pe care formatul nu le permite și arătați motivul în textul de stare.

Lungimea conținutului. Impuneți maximul pe care îl stochează aplicația. maxlength pe input trunchiază o scanare mai lungă fără eroare. Setați-l doar când fiecare conținut acceptat încape și comparați numărul de caractere din tester cu câmpul când o valoare pare scurtă.

Prefixe obligatorii. O verificare de prefix aparține aplicației. Această regulă de bilet acceptă QR- plus litere mari, cifre și cratime:

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

Eliminați un prefix de scaner doar când acel scaner este configurat să trimită un prefix exact și aplicația nu îl stochează. Un identificator de simbologie AIM este date până decideți altfel.

Formate specifice aplicației. Țineți regula lângă format. Un formular de bilet, o listă de URL-uri permise și un obiect JSON au nevoie de verificări diferite. Un singur tipar numeric va respinge text QR valid.

Scanări duplicate. O scanare fizică poate lovi doi ascultători. Folosiți o singură cale de încheiere, ca în exemplu. O a doua apăsare a trăgaciului este un eveniment separat. Exemplul respinge un conținut pe care l-a acceptat deja. Un formular de depozit ar putea incrementa o cantitate. Testați regula pe care o documentează aplicația.

JSON malformat. JSON.parse aruncă o excepție pe text incomplet. Verificați forma după o analiză reușită. Un tablou sau un număr simplu poate fi JSON valid și totuși tipul greșit:

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.' }
  }
}

URL-uri neașteptate. Analizați URL-ul ca să vedeți dacă este utilizabil, apoi păstrați șirul scanat dacă testul trebuie să se potrivească exact cu conținutul QR. URL.href poate adăuga o bară sau schimba codarea. Acceptați doar schemele pe care le intenționează aplicația. Nu deschideți URL-ul ca efect secundar al scanării:

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 }
}

Caractere de control. Respingeți caracterele de control ASCII dintr-un conținut de tastatură, ca un prefix ascuns să rămână vizibil în textul de stare. CR și LF sunt caractere de control. La un scaner pană, Enter și Tab sunt taste. Nu sunt caractere în interiorul unui input de text obișnuit. Un conținut serial poate conține în continuare octeți 0x0D sau 0x0A. Eliminați-i la limita de încadrare serială și nu eliminați un CR care aparține mijlocului unui conținut pe mai multe rânduri.

Sufixe ENTER și TAB

Un sufix este o configurare opțională a scanerului. Nu face parte din simbolul QR. Sufixe ENTER și TAB la scanerele de coduri de bare arată cum se deosebesc tastele. Citiți sufixul în testerul de introducere, apoi faceți pagina să urmeze scanerele pe care le instalați.

ENTER trimite formularul unui câmp de text pe un rând în browserele actuale. Folosiți asta când o scanare trebuie să confirme valoarea. Apelați preventDefault() pe submit când pagina trebuie să rămână pe loc.

TAB mută focalizarea la controlul următor. Citiți valoarea în keydown cât timp câmpul încă are focalizarea. Lăsați acțiunea implicită când câmpul următor trebuie să primească focalizarea. Ignorați Shift+Tab, ca un utilizator de tastatură să poată merge înapoi.

Fără sufix lasă conținutul în câmp. Butonul Accept din exemplu este calea de încheiere. Un temporizator de inactivitate poate presupune că o pauză înseamnă sfârșitul scanării. Acel temporizator este o euristică: o rafală Bluetooth lentă și o persoană care tastează repede pot trece ambele același interval. Preferați un sufix configurat când fluxul are nevoie de un sfârșit ferm.

CR și LF sunt octeți. Un Enter de tastatură este event.key === "Enter". Nu sunt interschimbabile. Un ascultător care elimină doar \r dintr-o valoare de input nu va vedea un Enter de pană, pentru că acel caracter nu a fost inserat. Un ascultător care urmărește doar event.key nu va despărți un buffer serial la 0x0D. Unele dispozitive trimit NumPad Enter. event.key este tot "Enter". Verificați event.key, nu doar event.code === "Enter".

Depanați evenimentele de tastatură

Când textul stocat este greșit, inspectați evenimentele în această ordine.

keydown. Se declanșează pentru fiecare tastă, inclusiv Enter și Tab, înainte ca browserul să insereze un caracter sau să mute focalizarea. Citiți terminatorul aici.

input. Se declanșează după ce un caracter tipăribil schimbă câmpul. Nu se declanșează pentru Enter sau Tab pe un input de text.

event.key. Caracterul sau numele tastei după ce sistemul de operare aplică dispunerea tastaturii.

event.code. Tasta fizică, cum este Digit1 sau Numpad1. Poate rămâne aceeași când o nepotrivire de dispunere schimbă event.key.

Focalizare. Înregistrați document.activeElement înainte de scanare. Dacă nu este câmpul QR, restul urmei descrie controlul greșit. Un iframe are propria focalizare.

Ordine. Pentru o scanare pană într-un câmp de text, evenimentele keydown tipăribile sunt urmate de actualizări input, apoi de un keydown final pentru Enter sau Tab când acel sufix este configurat. change se declanșează când câmpul confirmă valoarea, de obicei la blur. O scanare care lasă focalizarea în același câmp nu produce change la sfârșit. Nu folosiți change ca unic semnal de încheiere.

Temporizare. Scanerele termină adesea un conținut scurt mult sub o secundă. Testerul de introducere compară intervalul mediu dintre caractere cu un prag de 100 ms și etichetează rezultatul ca temporizare, nu ca identificare de hardware. O persoană care tastează repede, completarea automată sau emulatorul pot ajunge de partea scanerului a acelui prag. O scanare Bluetooth întârziată poate arăta ca tastarea. Afirmați conținutul și sufixul. Tratați temporizarea ca pe un indiciu.

Testerul de evenimente de tastatură listează fiecare keydown și keyup cu key, code, modificatori și marcaje de timp. Jurnalul este evenimente de browser. Nu este trafic USB brut.

Testați fără un scaner QR fizic

Logica aplicației poate fi testată înainte ca un scaner să fie pe birou.

  • Tastați QR-INPUT-TEST-12345 în câmp și activați Accept. Asta verifică validarea și afișarea. Nu verifică decodarea sau sufixele.
  • Conduceți același câmp dintr-un instrument de automatizare a browserului, cum face secțiunea următoare.
  • Folosiți Barcode Scanner Emulator când aveți nevoie de tastare în stilul unui scaner. Aplicația desktop trimite o valoare pe care o introduceți, cu o întârziere de tastare și un sufix niciunul, ENTER sau TAB, în aplicația focalizată. Reproduce calea de tastatură. Nu fotografiază o imagine QR, nu decodează un simbol și nu creează un port COM virtual.

Hardware-ul este în continuare necesar pentru comportamentul optic și al dispozitivului: dacă acel scaner poate citi codul afișat sau tipărit, dacă simbologia QR este activată, dispunerea tastaturii, configurarea sufixului și modurile seriale sau SDK de producător. Emulatorul este verificarea potrivită pentru calea de tastatură. Este verificarea nepotrivită pentru a dovedi că un dispozitiv citește un anumit cod QR.

Automatizați testele de introducere QR

Testele Playwright de mai jos conduc pagina exemplu. Tastează în câmp așa cum ar face un scaner pană, apoi afirmă comportamentul aplicației. Nu deschid dispozitive USB. @playwright/test este o dependență pentru cine rulează exemplul. Acest site nu o cere.

Salvați exemplul HTML ca qr-form.html lângă acest test.

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 inserează caractere în câmpul focalizat. Nu este un dispozitiv USB. Testul caracterelor neașteptate folosește fill, pentru că scopul este mesajul de validare și absența unui element injectat. Extindeți fișierul cu un caz de URL și un caz de JSON când acele formate sunt în versiunea pe care o livrați. O afirmație de URL ar trebui să compare textul capturat cu șirul QR original.

Matricea de test a scanerului QR

Rulați-le pe aplicația testată. Pagina exemplu de mai sus acoperă rândurile pentru bilet, URL, JSON, duplicat, gol și caractere neașteptate. O aplicație doar numerică sau pe mai multe rânduri are nevoie de propriul rezultat așteptat.

Scenariu Rezultat așteptat
QR cu text simplu Valoarea exactă primită
QR cu URL URL complet capturat, iar pagina nu navighează la el
QR numeric Cifrele păstrate
Caractere speciale Caracterele corecte primite
Conținut JSON Date capturate și validate
Sufix ENTER Prelucrarea are loc o dată
Sufix TAB Comportamentul focalizării tratat
Fără sufix Aplicația folosește un mecanism alternativ de încheiere
Scanare duplicată Aplicația aplică regulile de tratare a duplicatelor
Conținut nevalid Eroare de validare afișată
Focalizare lipsă Aplicația tratează în siguranță introducerea absentă
Conținut lung Fără trunchiere neintenționată

Scanați și un conținut care conține un rând nou, dacă produsul trebuie să stocheze unul. Notați dacă câmpul a primit fiecare rând.

Depanare

Începeți cu un conținut cunoscut în testerul de introducere. Dacă valoarea din tester este deja greșită, pagina nu este prima defecțiune. Dacă valoarea din tester este corectă și aplicația este greșită, defecțiunea este focalizarea, validarea sau tratarea evenimentelor. Scanerul de coduri de bare nu funcționează este lista mai largă de verificări ale dispozitivului. Cum se testează introducerea de la scanerul de coduri de bare acoperă focalizarea, dispunerea și fluxurile POS dincolo de acest formular.

Scanerul emite un bip, dar nu apare introducere

Un bip înseamnă de obicei că scanerul a decodat un simbol. Nu înseamnă că pagina a primit textul. Confirmați modul pană de tastatură. Modurile serial și cameră nu vor tasta în câmp. Faceți clic pe câmp, ca document.activeElement să fie acel input, apoi scanați din nou. Un câmp dezactivat, doar pentru citire sau ascuns poate ignora tastele.

Scanerul QR funcționează în Notepad, dar nu în browser

Dispozitivul tastează. Pagina nu acceptă acele taste. Verificați focalizarea, un ascultător keydown care apelează preventDefault() pe taste tipăribile și un ascultător care tratează doar paste. Introducerea pană nu declanșează un eveniment paste. Comparați rezultatul testerului cu câmpul aplicației.

Scanerul citește coduri de bare, dar nu coduri QR

Dispozitivul poate fi doar 1D, sau simbologia QR poate fi dezactivată. Pagina nu poate repara asta. Confirmați suportul 2D și activați QR Code din manualul dispozitivului, folosind verificările din Testarea codurilor QR: cum se testează scanerele de coduri QR. O scanare reușită Code 128 dovedește doar calea de tastatură.

Caractere incorecte

Scanați mai întâi QR-INPUT-TEST-12345. Dacă se potrivește și un conținut URL sau JSON nu, dispunerea schimbă punctuația, cum sunt :, /, { sau ". Comparați event.key cu event.code în testerul de evenimente de tastatură și vedeți Dispunere greșită a tastaturii scanerului de coduri de bare. Potriviți dispunerea tastaturii scanerului cu sistemul de operare.

ENTER trimite formularul de două ori

Browserul trimite formularul, iar un ascultător keydown tratează și el Enter. Păstrați o singură cale de încheiere și apelați preventDefault() acolo. O a doua scanare fizică este o defecțiune diferită. Textul de stare din exemplu spune că conținutul a fost deja acceptat. Dacă prima scanare însăși creează două înregistrări, căutați doi ascultători înainte să schimbați scanerul.

Introducerea QR este trunchiată

Comparați numărul de caractere din testerul de introducere cu valoarea din câmp. Un atribut maxlength, o mască de input sau preventDefault() pe tastele de caracter pot tăia șirul. Un rând nou în conținutul QR poate trimite devreme un input pe un rând. Unele scanere limitează și câte caractere tastează. Ridicați acea limită din manualul dispozitivului când testerul, nu doar aplicația, arată o valoare scurtă. Scanerului de coduri de bare îi lipsește ENTER acoperă cazul înrudit în care conținutul sosește și formularul nu confirmă niciodată.

Scanerul nu poate citi un cod QR de pe ecran

Confirmați că scanerul este un imager 2D. Creșteți luminozitatea ecranului, măriți dimensiunea codului și păstrați zona de liniște liberă de text și margini. Reflexia, un ecran de telefon întunecat și un cod prea dens pentru distanța de lucru sunt probleme optice. Tipăriți același conținut dacă citirea de pe ecran continuă să eșueze. Testul aplicației folosește în continuare șirul cunoscut odată ce orice scanare produce text.