ਮੁਫ਼ਤ ਪਰਿਵਰਤਕ

Regex ਟੈਸਟਰ

ਆਪਣੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਤੁਰੰਤ ਰੈਗੂਲਰ ਸਮੀਕਰਨਾਂ ਦੀ ਜਾਂਚ ਅਤੇ ਡੀਬੱਗ ਕਰੋ। ਮੈਚਾਂ ਨੂੰ ਹਾਈਲਾਈਟ ਕਰੋ, ਕੈਪਚਰ ਗਰੁੱਪ ਦੇਖੋ, ਅਤੇ ਰਿਪਲੇਸ ਮੋਡ ਦੀ ਵਰਤੋਂ ਕਰੋ — ਮੁਫਤ ਅਤੇ ਨਿੱਜੀ।

//g
ਝੰਡੇ:

ਇਸ ਟੂਲ ਬਾਰੇ

ਰੈਗੂਲਰ ਸਮੀਕਰਨ ਟੈਕਸਟ ਵਿੱਚ ਮੇਲ ਖਾਂਦੇ ਪੈਟਰਨਾਂ ਲਈ ਇੱਕ ਡੋਮੇਨ-ਵਿਸ਼ੇਸ਼ ਭਾਸ਼ਾ ਹਨ। ਉਹ 1968 ਤੋਂ ਕੰਪਿਊਟਿੰਗ ਦਾ ਹਿੱਸਾ ਰਹੇ ਹਨ ਅਤੇ ਹੁਣ ਹਰ ਆਧੁਨਿਕ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ, ਟੈਕਸਟ ਐਡੀਟਰ, ਅਤੇ ਕਮਾਂਡ-ਲਾਈਨ ਖੋਜ ਟੂਲ ਵਿੱਚ ਬਣਾਏ ਗਏ ਹਨ। ਸੰਟੈਕਸ ਸੰਖੇਪ ਹੈ ਪਰ ਗਲਤੀ-ਸੰਬੰਧੀ ਹੈ: ਛੋਟੀਆਂ ਤਬਦੀਲੀਆਂ ਬਿਲਕੁਲ ਵੱਖਰਾ ਮੈਚ ਵਿਵਹਾਰ ਪੈਦਾ ਕਰਦੀਆਂ ਹਨ, ਅਤੇ ਗੁੰਝਲਦਾਰ ਸਮੀਕਰਨ ਜਲਦੀ ਪੜ੍ਹਣਯੋਗ ਨਹੀਂ ਹੋ ਜਾਂਦੇ ਹਨ। ਇੱਕ ਟੈਸਟਰ ਜੋ ਰੀਅਲ ਟਾਈਮ ਵਿੱਚ ਮੈਚਾਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਪੈਟਰਨ ਨੂੰ ਸੰਪਾਦਿਤ ਕਰਦੇ ਹੋ ਤਾਂ ਰੀਜੈਕਸ ਨੂੰ ਵਿਕਸਤ ਕਰਨ ਅਤੇ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਤਰੀਕਾ ਹੈ।

ਇਹ ਟੈਸਟਰ JavaScript regex ਇੰਜਣ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਤੁਹਾਡੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਚੱਲਦਾ ਹੈ (ਜੇਕਰ ਇਹ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਚੱਲਦਾ ਹੈ ਤਾਂ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਵਰਤਦੀ ਹੈ)। ਪ੍ਰਤੀਕਿਰਿਆਤਮਕ ਤੌਰ 'ਤੇ ਪੈਟਰਨ ਅਤੇ ਟੈਸਟ ਟੈਕਸਟ ਅੱਪਡੇਟ: ਹਰੇਕ ਬਦਲਾਅ ਮੈਚ ਨੂੰ ਮੁੜ-ਚਲਾਉਂਦਾ ਹੈ। ਮੈਚ ਸਮੂਹਾਂ ਨੂੰ ਉਜਾਗਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਕੈਪਚਰ ਕੀਤੇ ਸਮੂਹਾਂ ਨੂੰ ਸੂਚੀਬੱਧ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਫਲੈਗ (ਕੇਸ-ਸੰਵੇਦਨਸ਼ੀਲ, ਮਲਟੀਲਾਈਨ, ਗਲੋਬਲ) ਟੈਸਟਿੰਗ ਲਈ ਸਾਹਮਣੇ ਆਉਂਦੇ ਹਨ।

Regex ਸੰਟੈਕਸ ਇੰਜਣਾਂ ਵਿਚਕਾਰ ਸੂਖਮ ਤੌਰ 'ਤੇ ਬਦਲਦਾ ਹੈ। JavaScript ECMAScript ਸਪੇਕ ਦੀ ਪਾਲਣਾ ਕਰਦਾ ਹੈ; ਪਾਈਥਨ, ਪੀਸੀਆਰਈ (PHP ਅਤੇ ਕਈ ਹੋਰਾਂ ਦੁਆਰਾ ਵਰਤੀ ਜਾਂਦੀ ਹੈ), Java, ਅਤੇ Go ਹਰੇਕ ਦੀਆਂ ਆਪਣੀਆਂ ਉਪਭਾਸ਼ਾਵਾਂ ਓਵਰਲੈਪਿੰਗ ਨਾਲ ਹਨ ਪਰ ਇੱਕੋ ਜਿਹੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨਹੀਂ ਹਨ। ਇੱਥੇ ਵਿਕਸਿਤ ਕੀਤੇ ਪੈਟਰਨ ECMAScript ਸੰਟੈਕਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ; ਕਰਾਸ-ਇੰਜਣ ਪੋਰਟੇਬਿਲਟੀ ਲਈ ਹਰੇਕ ਟੀਚੇ ਦੇ ਦਸਤਾਵੇਜ਼ਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਇੱਕ Regex ਟੈਸਟਰ ਦੀ ਵਰਤੋਂ ਕਿਉਂ ਕਰੋ

Regex ਬੱਗਾਂ ਨੂੰ ਤੈਨਾਤੀ ਤੋਂ ਬਾਅਦ ਡੀਬੱਗ ਕਰਨਾ ਬਹੁਤ ਔਖਾ ਹੈ। ਇੱਕ ਪੈਟਰਨ ਜੋ ਵਾਜਬ ਲੱਗਦਾ ਹੈ ਉਹ ਇਰਾਦੇ ਨਾਲੋਂ ਵੱਧ ਜਾਂ ਘੱਟ ਮੇਲ ਖਾਂਦਾ ਹੈ, ਕਿਨਾਰੇ ਦੇ ਮਾਮਲਿਆਂ ਵਿੱਚ ਅਸਫਲ ਹੋ ਸਕਦਾ ਹੈ, ਜਾਂ ਕੁਝ ਖਾਸ ਇਨਪੁਟਸ 'ਤੇ ਘਾਤਕ ਬੈਕਟ੍ਰੈਕਿੰਗ ਹੋ ਸਕਦਾ ਹੈ। ਕੋਡ ਸਮੀਖਿਆ ਅਤੇ ਉਤਪਾਦਨ ਤੋਂ ਪਹਿਲਾਂ ਪ੍ਰਤੀਨਿਧੀ ਇਨਪੁਟ ਦੇ ਵਿਰੁੱਧ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨਾਲ ਟੈਸਟਿੰਗ ਪੈਟਰਨ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਫੜਦਾ ਹੈ।

ਪੈਟਰਨਾਂ ਨੂੰ ਦਸਤਾਵੇਜ਼ਾਂ ਤੋਂ ਵੀ ਫਾਇਦਾ ਹੁੰਦਾ ਹੈ। ਇਨਪੁਟ ਦੇ ਨਾਲ ਇੱਕ regex ਦਿਖਾਉਣਾ ਇਹ ਮੇਲ ਖਾਂਦਾ ਹੈ ਅਤੇ ਜਿਸ ਇਨਪੁੱਟ ਨੂੰ ਇਹ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਇਰਾਦਾ ਸਪੱਸ਼ਟ ਕਰਦਾ ਹੈ। ਭਵਿੱਖ ਦੇ ਰੱਖ-ਰਖਾਅ ਕਰਨ ਵਾਲੇ (ਛੇ ਮਹੀਨਿਆਂ ਵਿੱਚ ਆਪਣੇ ਆਪ ਸਮੇਤ) ਦਸਤਾਵੇਜ਼ੀ ਟੈਸਟ ਦੇ ਕੇਸਾਂ ਦੀ ਜ਼ਿਆਦਾ ਕਦਰ ਕਰਦੇ ਹਨ ਜਿੰਨਾ ਕਿ ਉਹ ਚਲਾਕ ਇਕ-ਲਾਈਨਰ ਦੀ ਕਦਰ ਕਰਦੇ ਹਨ।

ਵਰਤਣ ਦਾ ਤਰੀਕਾ

ਇੱਕ ਪੈਟਰਨ ਟਾਈਪ ਕਰੋ, ਟੈਸਟ ਇਨਪੁਟ ਟਾਈਪ ਕਰੋ, ਲਾਈਵ ਹਾਈਲਾਈਟ ਕੀਤੇ ਮੈਚ ਦੇਖੋ।

  1. ਆਪਣਾ ਪੈਟਰਨ ਦਰਜ ਕਰੋ: ਪੈਟਰਨ ਖੇਤਰ ਵਿੱਚ regex ਪੈਟਰਨ ਟਾਈਪ ਕਰੋ। ਦੋਨੋ ਸ਼ਾਬਦਿਕ regex (/pattern/flags) ਅਤੇ ਪੈਟਰਨ-ਸਿਰਫ ਫਾਰਮ ਕੰਮ ਕਰਦੇ ਹਨ; ਝੰਡੇ ਫਲੈਗ ਇਨਪੁਟ ਦੁਆਰਾ ਸੈੱਟ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ।
  2. ਟੈਸਟ ਇਨਪੁੱਟ ਸ਼ਾਮਲ ਕਰੋ: ਨਮੂਨਾ ਟੈਕਸਟ ਪੇਸਟ ਕਰੋ ਜੋ ਪੈਟਰਨ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੋਵੇ (ਅਤੇ ਆਦਰਸ਼ਕ ਤੌਰ 'ਤੇ ਟੈਕਸਟ ਵੀ ਮੇਲ ਨਹੀਂ ਖਾਂਦਾ)। ਟੈਸਟਰ ਪੈਟਰਨ ਨੂੰ ਇਨਪੁਟ ਦੇ ਵਿਰੁੱਧ ਚਲਾਉਂਦਾ ਹੈ ਅਤੇ ਮੈਚਾਂ ਨੂੰ ਹਾਈਲਾਈਟ ਕਰਦਾ ਹੈ।
  3. ਝੰਡੇ ਸੈੱਟ ਕਰੋ: ਆਮ ਫਲੈਗ: g (ਗਲੋਬਲ, ਸਾਰੇ ਮੇਲ ਲੱਭੋ), i (ਕੇਸ-ਸੰਵੇਦਨਸ਼ੀਲ), m (ਮਲਟੀਲਾਈਨ, ^ ਅਤੇ $ ਮੈਚ ਲਾਈਨ ਸ਼ੁਰੂ/ਅੰਤ), s (ਡੋਟਲ, . ਨਵੀਆਂ ਲਾਈਨਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ), u (ਯੂਨੀਕੋਡ)।
  4. ਨਤੀਜਿਆਂ ਦੀ ਜਾਂਚ ਕਰੋ: ਹਰ ਮੈਚ ਨੂੰ ਇਨਪੁਟ ਵਿੱਚ ਉਜਾਗਰ ਕੀਤਾ ਗਿਆ ਹੈ। ਕੈਪਚਰ ਗਰੁੱਪ ਗਰੁੱਪ ਇੰਡੈਕਸ ਅਤੇ ਮੁੱਲ ਦੇ ਨਾਲ ਇੱਕ ਸੂਚੀ ਵਿੱਚ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ। ਟੈਸਟਰ ਮੈਚਾਂ ਦੀ ਗਿਣਤੀ ਅਤੇ ਪੈਟਰਨ ਵਿੱਚ ਕੋਈ ਵੀ ਸੰਕਲਨ ਗਲਤੀਆਂ ਵੀ ਦਿਖਾਉਂਦਾ ਹੈ।

ਆਮ ਵਰਤੋਂ ਦੇ ਮਾਮਲੇ

ਤਕਨੀਕੀ ਵੇਰਵੇ

JavaScript regex ECMAScript ਨਿਰਧਾਰਨ ਦੀ ਪਾਲਣਾ ਕਰਦਾ ਹੈ। ਮੁੱਖ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ: ਚਰਿੱਤਰ ਸ਼੍ਰੇਣੀਆਂ ([abc], [^abc]), ਕੁਆਂਟੀਫਾਇਰ (*, +,?, {n,m}), ਅਲਟਰਨੇਸ਼ਨ (|), ਗਰੁੱਪਿੰਗ (...)), ਕੈਪਚਰਿੰਗ ਅਤੇ ਗੈਰ-ਕੈਪਚਰਿੰਗ ਗਰੁੱਪ, ਲੁੱਕਅਹੇਡ ਅਤੇ ਲੁੱਕ ਬੀਹਾਈਂਡ (ਆਧੁਨਿਕ ਇੰਜਣ), ਬੈਕਰੇਫਰੈਂਸ, ਨਾਮ ਵਾਲੇ ਗਰੁੱਪ, ਯੂਨੀਕੋਡ ਪ੍ਰਾਪਰਟੀ ਏਸਕੇਪ (ਯੂਐਸਕੇਪ ਦੇ ਸਟੈਂਡਰਡ ਫਲੈਗ ਦੇ ਨਾਲ),

ਪੀਸੀਆਰਈ ਅਤੇ ਪਾਈਥਨ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਅੰਤਰ: ਜਾਵਾ ਸਕ੍ਰਿਪਟ (2018+) ਵਿੱਚ ਲੁੱਕਬੀਹਾਈਂਡ ਸਮਰਥਨ ਤਾਜ਼ਾ ਹੈ; ਨਾਮਿਤ ਸਮੂਹ (?<name>...) ਸੰਟੈਕਸ ਵਰਤਦੇ ਹਨ; ਕੁਝ ਯੂਨੀਕੋਡ ਐਸਕੇਪ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਯੂ ਫਲੈਗ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਅੰਤਰ-ਭਾਸ਼ਾ ਦੀ ਵਰਤੋਂ ਲਈ ਤਿਆਰ ਕੀਤੇ ਪੈਟਰਨਾਂ ਨੂੰ ਹਰੇਕ ਟੀਚੇ ਦੇ ਦਸਤਾਵੇਜ਼ਾਂ ਦੇ ਵਿਰੁੱਧ ਜਾਂਚਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।

ਪ੍ਰਦਰਸ਼ਨ: ਬੈਕਟ੍ਰੈਕਿੰਗ-ਅਧਾਰਿਤ ਰੇਜੈਕਸ ਇੰਜਣਾਂ (ਜ਼ਿਆਦਾਤਰ JavaScript ਸਮੇਤ) ਵਿੱਚ ਕੁਝ ਖਾਸ ਪੈਥੋਲੋਜੀਕਲ ਪੈਟਰਨਾਂ 'ਤੇ ਘਾਤਕ ਬੈਕਟ੍ਰੈਕਿੰਗ ਹੋ ਸਕਦੀ ਹੈ। ਟੈਸਟ ਜੋ ਟੈਸਟਰ ਨੂੰ ਲਟਕਦੇ ਹਨ ਉਹ ਇੱਕ ਸੰਕੇਤ ਹਨ ਕਿ ਪੈਟਰਨ ਨੂੰ ਸਰਲੀਕਰਨ ਦੀ ਲੋੜ ਹੈ - ਖਾਸ ਤੌਰ 'ਤੇ ਨੇਸਟਡ ਮਾਤਰਾਵਾਂ ਅਤੇ ਅਸਪਸ਼ਟ ਬਦਲਾਵ ਤੋਂ ਪਰਹੇਜ਼ ਕਰਕੇ।

ਵਧੀਆ ਅਭਿਆਸ

ਅਕਸਰ ਪੁੱਛੇ ਜਾਣ ਵਾਲੇ ਸਵਾਲ

ਇਹ ਟੂਲ ਕਿਸ regex ਸੁਆਦ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ?
ਇਹ JavaScript ਦੇ ਬਿਲਟ-ਇਨ RegExp ਇੰਜਣ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਜੋ ਸਟੈਂਡਰਡ ਸਿੰਟੈਕਸ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਲੁੱਕਅਹੈੱਡਸ, ਲੁੱਕ ਬੀਹਾਈਂਡਸ (ਆਧੁਨਿਕ ਬ੍ਰਾਊਜ਼ਰਾਂ ਵਿੱਚ), ਨਾਮਿਤ ਕੈਪਚਰ ਗਰੁੱਪ, ਅਤੇ ਯੂਨੀਕੋਡ ਪ੍ਰਾਪਰਟੀ ਐਸਕੇਪ ਸ਼ਾਮਲ ਹਨ।
ਕੀ ਮੈਂ regex ਤਬਦੀਲੀਆਂ ਦੀ ਜਾਂਚ ਕਰ ਸਕਦਾ ਹਾਂ?
ਹਾਂ। ਬਦਲੀ ਦਾ ਪੈਟਰਨ ਦਾਖਲ ਕਰਨ ਲਈ ਬਦਲੋ ਮੋਡ 'ਤੇ ਸਵਿਚ ਕਰੋ। ਤੁਸੀਂ ਗਰੁੱਪ ਬੈਕ-ਰੈਫਰੈਂਸ ਨੂੰ ਕੈਪਚਰ ਕਰਨ ਲਈ $1, $2, ਆਦਿ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਨਾਮ ਵਾਲੇ ਗਰੁੱਪਾਂ ਲਈ $<name>।
ਮੇਰਾ regex ਇੱਥੇ Python/PHP ਨਾਲੋਂ ਵੱਖਰਾ ਮੇਲ ਕਿਉਂ ਖਾਂਦਾ ਹੈ?
ਵੱਖ-ਵੱਖ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਥੋੜੇ ਵੱਖਰੇ ਰੇਜੈਕਸ ਇੰਜਣ ਹੁੰਦੇ ਹਨ। JavaScript ਅਧਿਕਾਰਤ ਮਾਤਰਾਵਾਂ ਜਾਂ ਕੁਝ PCRE-ਵਿਸ਼ੇਸ਼ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਾ ਸਮਰਥਨ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਕੋਰ ਸੰਟੈਕਸ (ਅੱਖਰ ਕਲਾਸਾਂ, ਮਾਤ੍ਰਾਕਾਰ, ਸਮੂਹ) ਸਾਰੀਆਂ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਇੱਕੋ ਜਿਹਾ ਹੈ।
ਕੀ ਟੂਲ ਮੇਰੇ regex ਪੈਟਰਨਾਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਦਾ ਹੈ?
ਨਹੀਂ। ਕੁਝ ਵੀ ਸੁਰੱਖਿਅਤ ਜਾਂ ਪ੍ਰਸਾਰਿਤ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਹ ਟੂਲ ਪੂਰੀ ਤਰ੍ਹਾਂ ਤੁਹਾਡੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਚੱਲਦਾ ਹੈ। ਤੁਸੀਂ regex ਸਤਰ ਦੀ ਨਕਲ ਕਰਕੇ ਪੈਟਰਨਾਂ ਨੂੰ ਬੁੱਕਮਾਰਕ ਜਾਂ ਸਾਂਝਾ ਕਰ ਸਕਦੇ ਹੋ।
ਮੈਂ ਇੱਕ ਸ਼ਾਬਦਿਕ ਵਿਸ਼ੇਸ਼ ਅੱਖਰ ਨਾਲ ਕਿਵੇਂ ਮੇਲ ਕਰਾਂ?
ਇੱਕ ਬੈਕਸਲੈਸ਼ ਨਾਲ ਇਸ ਨੂੰ ਬਚੋ. ਇੱਕ ਸ਼ਾਬਦਿਕ ਬਿੰਦੀ ਨਾਲ ਮੇਲ ਕਰਨ ਲਈ: \. ਇੱਕ ਸ਼ਾਬਦਿਕ ਬੈਕਸਲੈਸ਼ ਨਾਲ ਮੇਲ ਕਰਨ ਲਈ: \\. ਅੱਖਰ ਕਲਾਸਾਂ ਦੇ ਅੰਦਰ [...], ਜ਼ਿਆਦਾਤਰ ਵਿਸ਼ੇਸ਼ ਪਾਤਰ ਆਪਣਾ ਅਰਥ ਗੁਆ ਦਿੰਦੇ ਹਨ।
ਕੀ ਟੈਸਟਰ ਸਰਵਰ 'ਤੇ ਚੱਲ ਰਿਹਾ ਹੈ?
ਨੰਬਰ. ਪੈਟਰਨ ਦਾ ਸੰਕਲਨ ਅਤੇ ਮਿਲਾਨ ਮੂਲ RegExp ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤੁਹਾਡੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਹੁੰਦਾ ਹੈ।
ਕੀ ਮੈਂ ਗੈਰ-ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਇੰਜਣਾਂ ਲਈ ਪੈਟਰਨਾਂ ਦੀ ਜਾਂਚ ਕਰ ਸਕਦਾ ਹਾਂ?
ਜਿਆਦਾਤਰ। ਸਧਾਰਨ ਪੈਟਰਨ ਲਈ ਮੁੱਖ ਇੰਜਣ ਸਹਿਮਤ ਹਨ. ਉੱਨਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਲਈ (ਪਿੱਛੇ ਦੇਖੋ, ਪਰਮਾਣੂ ਸਮੂਹ, ਅਧਿਕਾਰਤ ਮਾਤਰਾਵਾਂ, ਯੂਨੀਕੋਡ ਪ੍ਰਾਪਰਟੀ ਐਸਕੇਪਸ), ਟੀਚੇ ਵਾਲੇ ਇੰਜਣ ਦੇ ਦਸਤਾਵੇਜ਼ਾਂ ਦੇ ਵਿਰੁੱਧ ਪੁਸ਼ਟੀ ਕਰੋ।
ਕੀ ਇਹ ਬਹੁਤ ਵੱਡੇ ਇੰਪੁੱਟ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ?
ਕੁਝ ਮੈਗਾਬਾਈਟ ਤੱਕ ਸੁਚਾਰੂ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ। ਵੱਡੇ ਇਨਪੁਟਸ ਬ੍ਰਾਊਜ਼ਰ ਨੂੰ ਹੌਲੀ ਜਾਂ ਲਟਕ ਸਕਦੇ ਹਨ, ਖਾਸ ਤੌਰ 'ਤੇ ਬੈਕਟਰੈਕਿੰਗ ਲਈ ਸੰਭਾਵਿਤ ਪੈਟਰਨਾਂ ਦੇ ਨਾਲ।