ਮੈਂ ਸਾਲਾਂ ਤੋਂ ਇੱਕ ਰੁਝਾਨ ਦੇਖਣ ਲਈ ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਫਰੰਟ-ਐਂਡ ਵਿਕਾਸ ਵਿੱਚ ਰਿਹਾ ਹਾਂ: ਇਸ ਦੇ ਇਤਿਹਾਸਕ ਸੰਦਰਭ ਨੂੰ ਸਮਝੇ ਬਿਨਾਂ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੇ ਇੱਕ ਨਵੇਂ ਪੈਰਾਡਾਈਮ ਨਾਲ ਕੰਮ ਕਰਨ ਵਾਲੇ ਨੌਜਵਾਨ ਡਿਵੈਲਪਰ। ਇਹ, ਬੇਸ਼ੱਕ, ਕੁਝ ਨਾ ਜਾਣਨਾ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਮਝਣ ਯੋਗ ਹੈ. ਵੈੱਬ ਹੁਨਰਾਂ ਅਤੇ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੇ ਵਿਭਿੰਨ ਸਮੂਹ ਦੇ ਨਾਲ ਇੱਕ ਬਹੁਤ ਵੱਡਾ ਸਥਾਨ ਹੈ, ਅਤੇ ਅਸੀਂ ਹਮੇਸ਼ਾ ਇਹ ਨਹੀਂ ਜਾਣਦੇ ਕਿ ਅਸੀਂ ਕੀ ਨਹੀਂ ਜਾਣਦੇ ਹਾਂ। ਇਸ ਖੇਤਰ ਵਿੱਚ ਸਿੱਖਣਾ ਇੱਕ ਨਿਰੰਤਰ ਯਾਤਰਾ ਹੈ ਨਾ ਕਿ ਕਿਸੇ ਅਜਿਹੀ ਚੀਜ਼ ਦੀ ਬਜਾਏ ਜੋ ਇੱਕ ਵਾਰ ਵਾਪਰਦਾ ਹੈ ਅਤੇ ਖਤਮ ਹੁੰਦਾ ਹੈ। ਬਿੰਦੂ ਵਿੱਚ ਕੇਸ: ਮੇਰੀ ਟੀਮ ਦੇ ਕਿਸੇ ਵਿਅਕਤੀ ਨੇ ਪੁੱਛਿਆ ਕਿ ਕੀ ਇਹ ਦੱਸਣਾ ਸੰਭਵ ਹੈ ਕਿ ਕੀ ਉਪਭੋਗਤਾ UI ਵਿੱਚ ਕਿਸੇ ਖਾਸ ਟੈਬ ਤੋਂ ਦੂਰ ਨੈਵੀਗੇਟ ਕਰਦੇ ਹਨ. ਮੈਂ JavaScript ਦੇ ਅਨਲੋਡ ਇਵੈਂਟ ਤੋਂ ਪਹਿਲਾਂ ਦੱਸਿਆ. ਪਰ ਜਿਨ੍ਹਾਂ ਨੇ ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਇਸ ਨਾਲ ਨਜਿੱਠਿਆ ਹੈ, ਉਹ ਜਾਣਦੇ ਹਨ ਕਿ ਇਹ ਸੰਭਵ ਹੈ ਕਿਉਂਕਿ ਉਹਨਾਂ ਨੂੰ ਹੋਰ ਸਾਈਟਾਂ 'ਤੇ ਅਣ-ਰੱਖਿਅਤ ਡੇਟਾ ਬਾਰੇ ਚੇਤਾਵਨੀਆਂ ਦਿੱਤੀਆਂ ਗਈਆਂ ਹਨ, ਜਿਸ ਲਈ ਪਹਿਲਾਂ ਅਨਲੋਡ ਇੱਕ ਆਮ ਵਰਤੋਂ ਦਾ ਮਾਮਲਾ ਹੈ। ਮੈਂ ਚੰਗੇ ਮਾਪ ਲਈ ਆਪਣੇ ਸਹਿਕਰਮੀ ਨੂੰ ਪੇਜਹਾਈਡ ਅਤੇ ਵਿਜ਼ੀਬਿਲਟੀ ਚੇਂਜ ਇਵੈਂਟਸ ਵੱਲ ਵੀ ਇਸ਼ਾਰਾ ਕੀਤਾ। ਮੈਨੂੰ ਇਸ ਬਾਰੇ ਕਿਵੇਂ ਪਤਾ ਲੱਗਾ? ਕਿਉਂਕਿ ਇਹ ਕਿਸੇ ਹੋਰ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਆਇਆ ਸੀ, ਇਸ ਲਈ ਨਹੀਂ ਕਿ ਮੈਂ ਸ਼ੁਰੂ ਵਿੱਚ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਸਿੱਖਣ ਵੇਲੇ ਇਸ ਦਾ ਅਧਿਐਨ ਕੀਤਾ ਸੀ। ਹਕੀਕਤ ਇਹ ਹੈ ਕਿ ਆਧੁਨਿਕ ਫਰੰਟ-ਐਂਡ ਫਰੇਮਵਰਕ ਉਨ੍ਹਾਂ ਤੋਂ ਪਹਿਲਾਂ ਵਾਲੇ ਤਕਨਾਲੋਜੀ ਦਿੱਗਜਾਂ ਦੇ ਮੋਢਿਆਂ 'ਤੇ ਖੜ੍ਹੇ ਹਨ. ਉਹ ਵਿਕਾਸ ਦੇ ਅਭਿਆਸਾਂ ਨੂੰ ਅਮੂਰਤ ਕਰਦੇ ਹਨ, ਅਕਸਰ ਇੱਕ ਬਿਹਤਰ ਡਿਵੈਲਪਰ ਅਨੁਭਵ ਲਈ ਜੋ ਘਟਾਉਂਦਾ ਹੈ, ਜਾਂ ਇੱਥੋਂ ਤੱਕ ਕਿ ਖਤਮ ਵੀ ਕਰਦਾ ਹੈ, ਇਹ ਜਾਣਨ ਜਾਂ ਛੂਹਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਕਿ ਰਵਾਇਤੀ ਤੌਰ 'ਤੇ ਜ਼ਰੂਰੀ ਫਰੰਟ-ਐਂਡ ਸੰਕਲਪ ਕੀ ਹਨ ਜੋ ਹਰ ਕਿਸੇ ਨੂੰ ਸ਼ਾਇਦ ਜਾਣਨਾ ਚਾਹੀਦਾ ਹੈ। CSS ਆਬਜੈਕਟ ਮਾਡਲ (CSSOM) 'ਤੇ ਵਿਚਾਰ ਕਰੋ। ਤੁਸੀਂ ਉਮੀਦ ਕਰ ਸਕਦੇ ਹੋ ਕਿ CSS ਅਤੇ JavaScript ਵਿੱਚ ਕੰਮ ਕਰਨ ਵਾਲੇ ਕਿਸੇ ਵੀ ਵਿਅਕਤੀ ਕੋਲ CSSOM ਅਨੁਭਵ ਦਾ ਇੱਕ ਸਮੂਹ ਹੈ, ਪਰ ਇਹ ਹਮੇਸ਼ਾ ਅਜਿਹਾ ਨਹੀਂ ਹੁੰਦਾ ਹੈ। ਇੱਕ ਈ-ਕਾਮਰਸ ਸਾਈਟ ਲਈ ਇੱਕ ਰੀਐਕਟ ਪ੍ਰੋਜੈਕਟ ਸੀ ਜਿਸ 'ਤੇ ਮੈਂ ਕੰਮ ਕੀਤਾ ਸੀ ਜਿੱਥੇ ਸਾਨੂੰ ਮੌਜੂਦਾ ਚੁਣੇ ਗਏ ਭੁਗਤਾਨ ਪ੍ਰਦਾਤਾ ਲਈ ਇੱਕ ਸਟਾਈਲਸ਼ੀਟ ਲੋਡ ਕਰਨ ਦੀ ਲੋੜ ਸੀ। ਸਮੱਸਿਆ ਇਹ ਸੀ ਕਿ ਸਟਾਈਲਸ਼ੀਟ ਹਰ ਪੰਨੇ 'ਤੇ ਲੋਡ ਹੋ ਰਹੀ ਸੀ ਜਦੋਂ ਇਹ ਸਿਰਫ਼ ਇੱਕ ਖਾਸ ਪੰਨੇ 'ਤੇ ਅਸਲ ਵਿੱਚ ਲੋੜੀਂਦਾ ਸੀ. ਇਸ ਨੂੰ ਵਾਪਰਨ ਦਾ ਕੰਮ ਕਰਨ ਵਾਲੇ ਡਿਵੈਲਪਰ ਨੇ ਕਦੇ ਵੀ ਸਟਾਈਲਸ਼ੀਟ ਨੂੰ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਲੋਡ ਨਹੀਂ ਕੀਤਾ ਸੀ। ਦੁਬਾਰਾ ਫਿਰ, ਇਹ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਮਝਣ ਯੋਗ ਹੈ ਜਦੋਂ ਪ੍ਰਤੀਕ੍ਰਿਆ ਉਸ ਰਵਾਇਤੀ ਪਹੁੰਚ ਨੂੰ ਦੂਰ ਕਰ ਦਿੰਦੀ ਹੈ ਜਿਸ ਲਈ ਤੁਸੀਂ ਪਹੁੰਚ ਸਕਦੇ ਹੋ। CSSOM ਸੰਭਾਵਤ ਤੌਰ 'ਤੇ ਤੁਹਾਡੇ ਰੋਜ਼ਾਨਾ ਦੇ ਕੰਮ ਵਿੱਚ ਲੋੜੀਂਦੀ ਚੀਜ਼ ਨਹੀਂ ਹੈ। ਪਰ ਇਹ ਸੰਭਾਵਨਾ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਕਿਸੇ ਸਮੇਂ ਇਸ ਨਾਲ ਗੱਲਬਾਤ ਕਰਨ ਦੀ ਲੋੜ ਪਵੇਗੀ, ਇੱਥੋਂ ਤੱਕ ਕਿ ਇੱਕ ਵਾਰ ਵਿੱਚ ਵੀ। ਇਨ੍ਹਾਂ ਤਜ਼ਰਬਿਆਂ ਨੇ ਮੈਨੂੰ ਇਹ ਲੇਖ ਲਿਖਣ ਲਈ ਪ੍ਰੇਰਿਤ ਕੀਤਾ। ਜੰਗਲੀ ਵਿੱਚ ਬਹੁਤ ਸਾਰੀਆਂ ਮੌਜੂਦਾ ਵੈਬ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਤਕਨਾਲੋਜੀਆਂ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ ਤੁਸੀਂ ਆਪਣੇ ਰੋਜ਼ਾਨਾ ਦੇ ਕੰਮ ਵਿੱਚ ਕਦੇ ਵੀ ਸਿੱਧੇ ਨਹੀਂ ਛੂਹ ਸਕਦੇ ਹੋ। ਸ਼ਾਇਦ ਤੁਸੀਂ ਵੈਬ ਡਿਵੈਲਪਮੈਂਟ ਲਈ ਬਿਲਕੁਲ ਨਵੇਂ ਹੋ ਅਤੇ ਉਹਨਾਂ ਤੋਂ ਸਿਰਫ਼ ਅਣਜਾਣ ਹੋ ਕਿਉਂਕਿ ਤੁਸੀਂ ਇੱਕ ਖਾਸ ਫਰੇਮਵਰਕ ਦੇ ਐਬਸਟਰੈਕਸ਼ਨ ਵਿੱਚ ਫਸ ਗਏ ਹੋ ਜਿਸ ਲਈ ਤੁਹਾਨੂੰ ਇਸ ਨੂੰ ਡੂੰਘਾਈ ਨਾਲ ਜਾਣਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਜਾਂ ਬਿਲਕੁਲ ਵੀ ਨਹੀਂ। ਮੈਂ ਖਾਸ ਤੌਰ 'ਤੇ XML ਬਾਰੇ ਗੱਲ ਕਰ ਰਿਹਾ ਹਾਂ, ਜੋ ਸਾਡੇ ਵਿੱਚੋਂ ਬਹੁਤ ਸਾਰੇ ਜਾਣਦੇ ਹਨ ਕਿ ਇੱਕ ਪ੍ਰਾਚੀਨ ਭਾਸ਼ਾ HTML ਤੋਂ ਬਿਲਕੁਲ ਵੱਖਰੀ ਨਹੀਂ ਹੈ. ਮੈਂ ਇਸ ਨੂੰ ਹਾਲ ਹੀ ਦੇ WHATWG ਚਰਚਾਵਾਂ ਦੇ ਕਾਰਨ ਲਿਆ ਰਿਹਾ ਹਾਂ ਜੋ ਸੁਝਾਅ ਦਿੰਦਾ ਹੈ ਕਿ XSLT ਪ੍ਰੋਗਰਾਮਿੰਗ ਵਜੋਂ ਜਾਣੇ ਜਾਂਦੇ XML ਸਟੈਕ ਦੇ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਹਿੱਸੇ ਨੂੰ ਬ੍ਰਾਊਜ਼ਰਾਂ ਤੋਂ ਹਟਾ ਦਿੱਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ ਬਿਲਕੁਲ ਉਸੇ ਤਰ੍ਹਾਂ ਦੀ ਪੁਰਾਣੀ, ਮੌਜੂਦਾ ਤਕਨਾਲੋਜੀ ਹੈ ਜੋ ਸਾਡੇ ਕੋਲ ਸਾਲਾਂ ਤੋਂ ਹੈ ਜੋ ਕਿ CSSOM ਸਥਿਤੀ ਦੇ ਰੂਪ ਵਿੱਚ ਵਿਹਾਰਕ ਲਈ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ ਜਿਵੇਂ ਕਿ ਮੇਰੀ ਟੀਮ ਸੀ. ਕੀ ਤੁਸੀਂ ਪਹਿਲਾਂ XSLT ਨਾਲ ਕੰਮ ਕੀਤਾ ਹੈ? ਆਓ ਦੇਖੀਏ ਕਿ ਕੀ ਅਸੀਂ ਇਸ ਪੁਰਾਣੀ ਤਕਨਾਲੋਜੀ ਵਿੱਚ ਬਹੁਤ ਜ਼ਿਆਦਾ ਝੁਕਦੇ ਹਾਂ ਅਤੇ ਅੱਜ ਅਸਲ-ਸੰਸਾਰ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਨਾਲ ਨਜਿੱਠਣ ਲਈ XML ਦੇ ਸੰਦਰਭ ਤੋਂ ਬਾਹਰ ਇਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਾ ਲਾਭ ਉਠਾਉਂਦੇ ਹਾਂ। XPath: ਕੇਂਦਰੀ API ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ XML ਤਕਨਾਲੋਜੀ ਜੋ ਸ਼ਾਇਦ ਇੱਕ ਸਿੱਧੇ XML ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ ਬਾਹਰ ਸਭ ਤੋਂ ਵੱਧ ਉਪਯੋਗੀ ਹੈ XPath, ਇੱਕ ਪੁੱਛਗਿੱਛ ਭਾਸ਼ਾ ਜੋ ਤੁਹਾਨੂੰ ਇੱਕ ਰੂਟ ਤੱਤ ਦੇ ਨਾਲ ਇੱਕ ਮਾਰਕਅੱਪ ਟ੍ਰੀ ਵਿੱਚ ਕੋਈ ਨੋਡ ਜਾਂ ਗੁਣ ਲੱਭਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ। ਮੈਨੂੰ XSLT ਲਈ ਇੱਕ ਨਿੱਜੀ ਪਿਆਰ ਹੈ, ਪਰ ਇਹ XPath 'ਤੇ ਵੀ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, ਅਤੇ ਵਿਅਕਤੀਗਤ ਪਿਆਰ ਨੂੰ ਦਰਜਾਬੰਦੀ ਦੇ ਮਹੱਤਵ ਵਿੱਚ ਇੱਕ ਪਾਸੇ ਰੱਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। XSLT ਨੂੰ ਹਟਾਉਣ ਲਈ ਦਲੀਲ XPath ਦਾ ਕੋਈ ਜ਼ਿਕਰ ਨਹੀਂ ਕਰਦੀ, ਇਸ ਲਈ ਮੈਂ ਮੰਨਦਾ ਹਾਂ ਕਿ ਇਹ ਅਜੇ ਵੀ ਆਗਿਆ ਹੈ. ਇਹ ਚੰਗਾ ਹੈ ਕਿਉਂਕਿ XPath ਤਕਨਾਲੋਜੀ ਦੇ ਇਸ ਸੂਟ ਵਿੱਚ ਕੇਂਦਰੀ ਅਤੇ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ API ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ ਆਮ XML ਵਰਤੋਂ ਤੋਂ ਬਾਹਰ ਵਰਤਣ ਲਈ ਕੁਝ ਲੱਭਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ, ਜਦੋਂ ਕਿ CSS ਚੋਣਕਾਰ ਤੁਹਾਡੇ ਪੰਨੇ ਦੇ ਜ਼ਿਆਦਾਤਰ ਤੱਤਾਂ ਨੂੰ ਲੱਭਣ ਲਈ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ, ਉਹ ਉਹਨਾਂ ਸਾਰਿਆਂ ਨੂੰ ਨਹੀਂ ਲੱਭ ਸਕਦੇ। ਇਸ ਤੋਂ ਇਲਾਵਾ, CSS ਚੋਣਕਾਰਾਂ ਨੂੰ DOM ਵਿੱਚ ਇਸਦੀ ਮੌਜੂਦਾ ਸਥਿਤੀ ਦੇ ਅਧਾਰ ਤੇ ਇੱਕ ਤੱਤ ਲੱਭਣ ਲਈ ਨਹੀਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ। XPath ਕਰ ਸਕਦਾ ਹੈ। ਹੁਣ, ਤੁਹਾਡੇ ਵਿੱਚੋਂ ਕੁਝ ਇਸ ਨੂੰ ਪੜ੍ਹ ਰਹੇ ਹੋ ਸਕਦੇ ਹਨ XPath ਜਾਣਦੇ ਹਨ, ਅਤੇ ਕੁਝ ਨਹੀਂ ਜਾਣਦੇ। XPath ਟੈਕਨਾਲੋਜੀ ਦਾ ਇੱਕ ਬਹੁਤ ਵੱਡਾ ਖੇਤਰ ਹੈ, ਅਤੇ ਮੈਂ ਅਸਲ ਵਿੱਚ ਸਾਰੀਆਂ ਬੁਨਿਆਦੀ ਗੱਲਾਂ ਨਹੀਂ ਸਿਖਾ ਸਕਦਾ ਹਾਂ ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਇੱਕ ਲੇਖ ਵਿੱਚ ਤੁਹਾਨੂੰ ਇਸ ਨਾਲ ਕਰਨ ਲਈ ਵਧੀਆ ਚੀਜ਼ਾਂ ਵੀ ਨਹੀਂ ਦਿਖਾ ਸਕਦਾ ਹਾਂ। ਮੈਂ ਅਸਲ ਵਿੱਚ ਉਹ ਲੇਖ ਲਿਖਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ, ਪਰ ਔਸਤ ਸਮੈਸ਼ਿੰਗ ਮੈਗਜ਼ੀਨ ਪ੍ਰਕਾਸ਼ਨ 5,000 ਸ਼ਬਦਾਂ ਤੋਂ ਵੱਧ ਨਹੀਂ ਹੈ। ਮੈਂ ਪਹਿਲਾਂ ਹੀ ਇਸ ਤੋਂ ਵੱਧ ਸੀ2,000 ਸ਼ਬਦ ਜਦੋਂ ਕਿ ਮੂਲ ਗੱਲਾਂ ਦੇ ਅੱਧੇ ਰਸਤੇ ਵਿੱਚ। ਇਸ ਲਈ, ਮੈਂ XPath ਨਾਲ ਵਧੀਆ ਚੀਜ਼ਾਂ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਨ ਜਾ ਰਿਹਾ ਹਾਂ ਅਤੇ ਤੁਹਾਨੂੰ ਕੁਝ ਲਿੰਕ ਦੇਣ ਜਾ ਰਿਹਾ ਹਾਂ ਜੋ ਤੁਸੀਂ ਮੂਲ ਲਈ ਵਰਤ ਸਕਦੇ ਹੋ ਜੇਕਰ ਤੁਹਾਨੂੰ ਇਹ ਸਮੱਗਰੀ ਦਿਲਚਸਪ ਲੱਗਦੀ ਹੈ। XPath ਅਤੇ CSS ਨੂੰ ਜੋੜਨਾ XPath ਬਹੁਤ ਸਾਰੀਆਂ ਚੀਜ਼ਾਂ ਕਰ ਸਕਦਾ ਹੈ ਜੋ CSS ਚੋਣਕਾਰ ਤੱਤਾਂ ਦੀ ਪੁੱਛਗਿੱਛ ਕਰਨ ਵੇਲੇ ਨਹੀਂ ਕਰ ਸਕਦੇ ਹਨ। ਪਰ CSS ਚੋਣਕਾਰ ਕੁਝ ਚੀਜ਼ਾਂ ਵੀ ਕਰ ਸਕਦੇ ਹਨ ਜੋ XPath ਨਹੀਂ ਕਰ ਸਕਦੇ ਹਨ, ਅਰਥਾਤ, ਕਲਾਸ ਦੇ ਨਾਮ ਦੁਆਰਾ ਤੱਤਾਂ ਦੀ ਪੁੱਛਗਿੱਛ.
CSS XPath .myClass /*[ਸ਼ਾਮਲ ਹੈ(@class, "myClass")]
ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, CSS ਸਵਾਲਾਂ ਦੇ ਤੱਤ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਇੱਕ .myClass ਕਲਾਸਨਾਮ ਹੁੰਦਾ ਹੈ। ਇਸ ਦੌਰਾਨ, XPath ਉਦਾਹਰਨ ਐਲੀਮੈਂਟਸ ਦੀ ਪੁੱਛਗਿੱਛ ਕਰਦੀ ਹੈ ਜਿਸ ਵਿੱਚ "myClass" ਸਤਰ ਦੇ ਨਾਲ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਕਲਾਸ ਸ਼ਾਮਲ ਹੁੰਦੀ ਹੈ। ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਇਹ ਕਿਸੇ ਵੀ ਵਿਸ਼ੇਸ਼ਤਾ ਵਿੱਚ myClass ਵਾਲੇ ਐਲੀਮੈਂਟਸ ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ .myClass ਕਲਾਸਨਾਮ ਵਾਲੇ ਤੱਤ ਵੀ ਸ਼ਾਮਲ ਹਨ — ਨਾਲ ਹੀ ਸਤਰ ਵਿੱਚ “myClass” ਵਾਲੇ ਤੱਤ, ਜਿਵੇਂ ਕਿ .myClass2। XPath ਇਸ ਅਰਥ ਵਿੱਚ ਵਿਆਪਕ ਹੈ। ਇਸ ਲਈ, ਨਹੀਂ. ਮੈਂ ਇਹ ਸੁਝਾਅ ਨਹੀਂ ਦੇ ਰਿਹਾ ਹਾਂ ਕਿ ਸਾਨੂੰ CSS ਨੂੰ ਬਾਹਰ ਕੱਢਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ XPath ਦੁਆਰਾ ਸਾਰੇ ਤੱਤ ਚੁਣਨਾ ਸ਼ੁਰੂ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ. ਇਹ ਬਿੰਦੂ ਨਹੀਂ ਹੈ. ਬਿੰਦੂ ਇਹ ਹੈ ਕਿ XPath ਉਹ ਚੀਜ਼ਾਂ ਕਰ ਸਕਦਾ ਹੈ ਜੋ CSS ਨਹੀਂ ਕਰ ਸਕਦਾ ਅਤੇ ਅਜੇ ਵੀ ਬਹੁਤ ਉਪਯੋਗੀ ਹੋ ਸਕਦਾ ਹੈ, ਭਾਵੇਂ ਇਹ ਬ੍ਰਾਊਜ਼ਰ ਸਟੈਕ ਵਿੱਚ ਇੱਕ ਪੁਰਾਣੀ ਤਕਨਾਲੋਜੀ ਹੈ ਅਤੇ ਪਹਿਲੀ ਨਜ਼ਰ ਵਿੱਚ ਸਪੱਸ਼ਟ ਨਹੀਂ ਜਾਪਦੀ ਹੈ। ਆਉ ਅਸੀਂ ਦੋ ਤਕਨੀਕਾਂ ਨੂੰ ਇਕੱਠੇ ਵਰਤੀਏ ਕਿਉਂਕਿ ਅਸੀਂ ਕਰ ਸਕਦੇ ਹਾਂ, ਪਰ ਕਿਉਂਕਿ ਅਸੀਂ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ XPath ਬਾਰੇ ਕੁਝ ਸਿੱਖਾਂਗੇ, ਇਸ ਨੂੰ ਤੁਹਾਡੇ ਸਟੈਕ ਵਿੱਚ ਇੱਕ ਹੋਰ ਟੂਲ ਬਣਾਵਾਂਗੇ — ਜਿਸ ਬਾਰੇ ਤੁਸੀਂ ਸ਼ਾਇਦ ਨਹੀਂ ਜਾਣਦੇ ਹੋਵੋਗੇ ਕਿ ਉੱਥੇ ਮੌਜੂਦ ਹੈ! ਸਮੱਸਿਆ ਇਹ ਹੈ ਕਿ JavaScript ਦੀ document.evaluate ਵਿਧੀ ਅਤੇ ਵੱਖ-ਵੱਖ ਪੁੱਛਗਿੱਛ ਚੋਣਕਾਰ ਵਿਧੀਆਂ ਜੋ ਅਸੀਂ JavaScript ਲਈ CSS APIs ਨਾਲ ਵਰਤਦੇ ਹਾਂ, ਅਸੰਗਤ ਹਨ। ਮੈਂ ਸਾਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਇੱਕ ਅਨੁਕੂਲ ਪੁੱਛਗਿੱਛ API ਬਣਾਇਆ ਹੈ, ਹਾਲਾਂਕਿ ਇਹ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ, ਮੈਂ ਇਸ ਵਿੱਚ ਬਹੁਤ ਜ਼ਿਆਦਾ ਵਿਚਾਰ ਨਹੀਂ ਕੀਤਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਅਸੀਂ ਇੱਥੇ ਕੀ ਕਰ ਰਹੇ ਹਾਂ ਤੋਂ ਇੱਕ ਵਿਦਾਇਗੀ ਹੈ. ਇੱਥੇ ਇੱਕ ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਪੁੱਛਗਿੱਛ ਕੰਸਟਰਕਟਰ ਦੀ ਇੱਕ ਕਾਫ਼ੀ ਸਧਾਰਨ ਕਾਰਜਸ਼ੀਲ ਉਦਾਹਰਨ ਹੈ: Bryan Rasmussen ਦੁਆਰਾ Pen queryXPath [forked] ਦੇਖੋ। ਮੈਂ ਦਸਤਾਵੇਜ਼ ਆਬਜੈਕਟ 'ਤੇ ਦੋ ਤਰੀਕੇ ਸ਼ਾਮਲ ਕੀਤੇ ਹਨ: queryCSSSelectors (ਜੋ ਕਿ ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ querySelectorAll ਹੈ) ਅਤੇ queryXPaths। ਇਹ ਦੋਵੇਂ ਇੱਕ queryResults ਆਬਜੈਕਟ ਵਾਪਸ ਕਰਦੇ ਹਨ:
{ ਪੁੱਛਗਿੱਛ ਦੀ ਕਿਸਮ: ਨੋਡ | ਸਤਰ | ਨੰਬਰ | ਬੁਲੀਅਨ, ਨਤੀਜੇ: ਕੋਈ[] // html ਐਲੀਮੈਂਟਸ, xml ਐਲੀਮੈਂਟਸ, ਸਤਰ, ਨੰਬਰ, ਬੁਲੀਅਨ, queryCSSSelectors: (query: string, amend: boolean) => ਪੁੱਛਗਿੱਛ ਦੇ ਨਤੀਜੇ, queryXpaths: (query: string, amend: boolean) => query Results }
queryCSSSelectors ਅਤੇ queryXpaths ਫੰਕਸ਼ਨ ਉਸ ਪੁੱਛਗਿੱਛ ਨੂੰ ਚਲਾਉਂਦੇ ਹਨ ਜੋ ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ ਨਤੀਜੇ ਐਰੇ ਵਿੱਚ ਐਲੀਮੈਂਟਸ ਉੱਤੇ ਦਿੰਦੇ ਹੋ, ਜਦੋਂ ਤੱਕ ਨਤੀਜੇ ਐਰੇ ਕਿਸਮ ਦੇ ਨੋਡਾਂ ਦੇ ਹੁੰਦੇ ਹਨ। ਨਹੀਂ ਤਾਂ, ਇਹ ਇੱਕ ਖਾਲੀ ਐਰੇ ਅਤੇ ਨੋਡਸ ਦੀ ਇੱਕ ਕਿਸਮ ਦੇ ਨਾਲ ਇੱਕ ਸਵਾਲ ਦਾ ਨਤੀਜਾ ਵਾਪਸ ਕਰੇਗਾ। ਜੇਕਰ ਸੋਧ ਵਿਸ਼ੇਸ਼ਤਾ ਸਹੀ 'ਤੇ ਸੈੱਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਫੰਕਸ਼ਨ ਆਪਣੇ ਖੁਦ ਦੇ ਪੁੱਛਗਿੱਛ ਨਤੀਜੇ ਬਦਲ ਦੇਣਗੇ। ਕਿਸੇ ਵੀ ਸਥਿਤੀ ਵਿੱਚ ਇਸਦੀ ਵਰਤੋਂ ਉਤਪਾਦਨ ਦੇ ਵਾਤਾਵਰਣ ਵਿੱਚ ਨਹੀਂ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ। ਮੈਂ ਦੋ ਸਵਾਲ API ਨੂੰ ਇਕੱਠੇ ਵਰਤਣ ਦੇ ਵੱਖ-ਵੱਖ ਪ੍ਰਭਾਵਾਂ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਲਈ ਇਸ ਤਰ੍ਹਾਂ ਕਰ ਰਿਹਾ ਹਾਂ. ਉਦਾਹਰਨ ਸਵਾਲ ਮੈਂ ਵੱਖ-ਵੱਖ XPath ਸਵਾਲਾਂ ਦੀਆਂ ਕੁਝ ਉਦਾਹਰਣਾਂ ਦਿਖਾਉਣਾ ਚਾਹੁੰਦਾ ਹਾਂ ਜੋ ਕੁਝ ਸ਼ਕਤੀਸ਼ਾਲੀ ਚੀਜ਼ਾਂ ਦਾ ਪ੍ਰਦਰਸ਼ਨ ਕਰਦੇ ਹਨ ਜੋ ਉਹ ਕਰ ਸਕਦੇ ਹਨ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਹੋਰ ਪਹੁੰਚਾਂ ਦੀ ਥਾਂ 'ਤੇ ਕਿਵੇਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਪਹਿਲੀ ਉਦਾਹਰਨ ਹੈ //li/text(). ਇਹ ਸਾਰੇ li ਤੱਤਾਂ ਦੀ ਪੁੱਛਗਿੱਛ ਕਰਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਦੇ ਟੈਕਸਟ ਨੋਡਾਂ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਸ ਲਈ, ਜੇਕਰ ਅਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ HTML ਦੀ ਪੁੱਛਗਿੱਛ ਕਰਨੀ ਸੀ:
- ਇੱਕ
- ਦੋ
- ਤਿੰਨ
…ਇਹ ਉਹ ਹੈ ਜੋ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ:
{"queryType":"xpathEvaluate","results":["one","two","three"],"resultType":"string"}
ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਸਾਨੂੰ ਹੇਠ ਦਿੱਤੀ ਐਰੇ ਮਿਲਦੀ ਹੈ: ["ਇੱਕ","ਦੋ","ਤਿੰਨ"]। ਆਮ ਤੌਰ 'ਤੇ, ਤੁਸੀਂ li ਐਲੀਮੈਂਟਸ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਪੁੱਛਗਿੱਛ ਕਰੋਗੇ, ਉਸ ਪੁੱਛਗਿੱਛ ਦੇ ਨਤੀਜੇ ਨੂੰ ਇੱਕ ਐਰੇ ਵਿੱਚ ਬਦਲੋ, ਐਰੇ ਨੂੰ ਮੈਪ ਕਰੋ, ਅਤੇ ਹਰੇਕ ਐਲੀਮੈਂਟ ਦਾ ਟੈਕਸਟ ਨੋਡ ਵਾਪਸ ਕਰੋ। ਪਰ ਅਸੀਂ ਇਸਨੂੰ XPath ਨਾਲ ਹੋਰ ਸੰਖੇਪ ਰੂਪ ਵਿੱਚ ਕਰ ਸਕਦੇ ਹਾਂ: document.queryXPaths("//li/text()").ਨਤੀਜੇ।
ਧਿਆਨ ਦਿਓ ਕਿ ਟੈਕਸਟ ਨੋਡ ਪ੍ਰਾਪਤ ਕਰਨ ਦਾ ਤਰੀਕਾ ਹੈ ਟੈਕਸਟ(), ਜੋ ਕਿ ਇੱਕ ਫੰਕਸ਼ਨ ਹਸਤਾਖਰ ਵਰਗਾ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ - ਅਤੇ ਇਹ ਹੈ. ਇਹ ਇੱਕ ਤੱਤ ਦਾ ਟੈਕਸਟ ਨੋਡ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਸਾਡੀ ਉਦਾਹਰਨ ਵਿੱਚ, ਮਾਰਕਅੱਪ ਵਿੱਚ ਤਿੰਨ li ਤੱਤ ਹਨ, ਹਰੇਕ ਵਿੱਚ ਟੈਕਸਟ ("ਇੱਕ", "ਦੋ", ਅਤੇ "ਤਿੰਨ") ਹੁੰਦਾ ਹੈ।
ਆਉ ਇੱਕ ਟੈਕਸਟ() ਪੁੱਛਗਿੱਛ ਦੀ ਇੱਕ ਹੋਰ ਉਦਾਹਰਣ ਵੇਖੀਏ। ਮੰਨ ਲਓ ਕਿ ਇਹ ਸਾਡਾ ਮਾਰਕਅੱਪ ਹੈ:
ਚਲੋ ਇੱਕ ਪੁੱਛਗਿੱਛ ਲਿਖੀਏ ਜੋ href ਵਿਸ਼ੇਸ਼ਤਾ ਮੁੱਲ ਵਾਪਸ ਕਰਦੀ ਹੈ: document.queryXPaths("//a[text() = 'ਸਾਈਨ ਇਨ']/@href").ਨਤੀਜੇ।
ਇਹ ਮੌਜੂਦਾ ਦਸਤਾਵੇਜ਼ 'ਤੇ ਇੱਕ XPath ਪੁੱਛਗਿੱਛ ਹੈ, ਜਿਵੇਂ ਕਿ ਪਿਛਲੀ ਉਦਾਹਰਨ ਦੀ ਤਰ੍ਹਾਂ, ਪਰ ਇਸ ਵਾਰ ਅਸੀਂ ਇੱਕ ਲਿੰਕ (ਇੱਕ ਤੱਤ) ਦੀ href ਵਿਸ਼ੇਸ਼ਤਾ ਵਾਪਸ ਕਰਦੇ ਹਾਂ ਜਿਸ ਵਿੱਚ "ਸਾਈਨ ਇਨ" ਟੈਕਸਟ ਹੈ। ਅਸਲ ਵਾਪਸ ਆ ਗਿਆਨਤੀਜਾ ["/login.html"] ਹੈ। XPath ਫੰਕਸ਼ਨ ਸੰਖੇਪ ਜਾਣਕਾਰੀ ਇੱਥੇ ਬਹੁਤ ਸਾਰੇ XPath ਫੰਕਸ਼ਨ ਹਨ, ਅਤੇ ਤੁਸੀਂ ਸ਼ਾਇਦ ਉਹਨਾਂ ਤੋਂ ਅਣਜਾਣ ਹੋ। ਮੇਰੇ ਖਿਆਲ ਵਿੱਚ, ਇੱਥੇ ਬਹੁਤ ਸਾਰੇ ਹਨ, ਜਿਨ੍ਹਾਂ ਬਾਰੇ ਜਾਣਨ ਯੋਗ ਹਨ, ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਹੇਠ ਲਿਖੇ ਸ਼ਾਮਲ ਹਨ:
starts-withਜੇਕਰ ਕੋਈ ਟੈਕਸਟ ਕਿਸੇ ਖਾਸ ਹੋਰ ਟੈਕਸਟ ਉਦਾਹਰਨ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ, starts-with(@href, 'http:') ਸਹੀ ਵਾਪਸ ਆਉਂਦਾ ਹੈ ਜੇਕਰ ਇੱਕ href ਗੁਣ http: ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ। ਜੇਕਰ ਕਿਸੇ ਟੈਕਸਟ ਵਿੱਚ ਇੱਕ ਖਾਸ ਹੋਰ ਟੈਕਸਟ ਉਦਾਹਰਨ ਸ਼ਾਮਲ ਹੁੰਦੀ ਹੈ, ਤਾਂ contains(text(), "ਸਮੈਸ਼ਿੰਗ ਮੈਗਜ਼ੀਨ") ਸਹੀ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇਕਰ ਇੱਕ ਟੈਕਸਟ ਨੋਡ ਵਿੱਚ ਕਿਤੇ ਵੀ "ਸਮੈਸ਼ਿੰਗ ਮੈਗਜ਼ੀਨ" ਸ਼ਬਦ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ। count ਇੱਕ ਪੁੱਛਗਿੱਛ ਲਈ ਕਿੰਨੇ ਮੇਲ ਹਨ ਦੀ ਗਿਣਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, count(//*[starts-with(@href, 'http:']) ਇਸ ਗੱਲ ਦੀ ਗਿਣਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ ਕਿ ਸੰਦਰਭ ਨੋਡ ਵਿੱਚ ਕਿੰਨੇ ਲਿੰਕ ਇੱਕ href ਗੁਣ ਵਾਲੇ ਤੱਤ ਹਨ ਜਿਸ ਵਿੱਚ http: ਨਾਲ ਸ਼ੁਰੂ ਹੋਣ ਵਾਲਾ ਟੈਕਸਟ ਸ਼ਾਮਲ ਹੈ। ਸਬਸਟਰਿੰਗ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਸਬਸਟਰਿੰਗ ਵਾਂਗ ਕੰਮ ਕਰਦੀ ਹੈ, ਸਿਵਾਏ ਤੁਸੀਂ ਸਟ੍ਰਿੰਗ ਨੂੰ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਪਾਸ ਕਰਦੇ ਹੋ। ਉਦਾਹਰਨ ਲਈ, ਸਬਸਟਰਿੰਗ("ਮੇਰਾ ਟੈਕਸਟ", 2, 4) "y t" ਵਾਪਸ ਕਰਦਾ ਹੈ। substring-before ਕਿਸੇ ਹੋਰ ਸਟ੍ਰਿੰਗ ਤੋਂ ਪਹਿਲਾਂ ਸਟ੍ਰਿੰਗ ਦਾ ਹਿੱਸਾ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, substing-before("my text", "") "my" ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਸੇ ਤਰ੍ਹਾਂ, substring-before("hi","bye") ਇੱਕ ਖਾਲੀ ਸਤਰ ਵਾਪਸ ਕਰਦਾ ਹੈ। substring-afterਇੱਕ ਸਟ੍ਰਿੰਗ ਦੇ ਬਾਅਦ ਦੂਜੀ ਸਟ੍ਰਿੰਗ ਦਾ ਹਿੱਸਾ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, substing-after("my text", " ") "text" ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਸੇ ਤਰ੍ਹਾਂ, ਸਬਸਟਰਿੰਗ-ਬਾਅਦ("hi","bye") ਇੱਕ ਖਾਲੀ ਸਤਰ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਸਧਾਰਣ-ਸਪੇਸ ਲੀਡਿੰਗ ਅਤੇ ਟ੍ਰੇਲਿੰਗ ਵ੍ਹਾਈਟਸਪੇਸ ਨੂੰ ਸਟ੍ਰਿਪ ਕਰਕੇ ਅਤੇ ਵ੍ਹਾਈਟਸਪੇਸ ਅੱਖਰਾਂ ਦੇ ਕ੍ਰਮ ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਸਪੇਸ ਦੁਆਰਾ ਬਦਲ ਕੇ ਸਧਾਰਣ ਵ੍ਹਾਈਟਸਪੇਸ ਦੇ ਨਾਲ ਆਰਗੂਮੈਂਟ ਸਟ੍ਰਿੰਗ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਆਰਗੂਮੈਂਟ ਗਲਤ ਹੈ, ਨਹੀਂ ਤਾਂ ਬੂਲੀਅਨ ਸੱਚ ਵਾਪਸ ਨਹੀਂ ਕਰਦਾ। true ਬੁਲੀਅਨ ਸੱਚ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਗਲਤ ਬੁਲੀਅਨ ਗਲਤ ਵਾਪਸ ਕਰਦਾ ਹੈ। concatJavaScript concat ਵਰਗੀ ਹੀ ਚੀਜ਼, ਸਿਵਾਏ ਤੁਸੀਂ ਇਸਨੂੰ ਇੱਕ ਸਤਰ 'ਤੇ ਇੱਕ ਵਿਧੀ ਦੇ ਤੌਰ ਤੇ ਨਹੀਂ ਚਲਾਉਂਦੇ ਹੋ। ਇਸਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਉਹਨਾਂ ਸਾਰੀਆਂ ਸਤਰਾਂ ਵਿੱਚ ਪਾ ਦਿੰਦੇ ਹੋ ਜੋ ਤੁਸੀਂ ਜੋੜਨਾ ਚਾਹੁੰਦੇ ਹੋ। ਸਟ੍ਰਿੰਗ-ਲੰਬਾਈ ਇਹ JavaScript ਸਟ੍ਰਿੰਗ-ਲੰਬਾਈ ਦੇ ਸਮਾਨ ਨਹੀਂ ਹੈ, ਸਗੋਂ ਸਟ੍ਰਿੰਗ ਦੀ ਲੰਬਾਈ ਵਾਪਸ ਕਰਦੀ ਹੈ ਜੋ ਇਸਨੂੰ ਇੱਕ ਆਰਗੂਮੈਂਟ ਵਜੋਂ ਦਿੱਤੀ ਗਈ ਹੈ। translateThis ਇੱਕ ਸਤਰ ਲੈਂਦਾ ਹੈ ਅਤੇ ਦੂਜੀ ਆਰਗੂਮੈਂਟ ਨੂੰ ਤੀਜੀ ਆਰਗੂਮੈਂਟ ਵਿੱਚ ਬਦਲਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਅਨੁਵਾਦ ਕਰੋ("abcdef", "abc", "XYZ") XYZdef ਆਊਟਪੁੱਟ।
ਇਹਨਾਂ ਖਾਸ XPath ਫੰਕਸ਼ਨਾਂ ਤੋਂ ਇਲਾਵਾ, ਇੱਥੇ ਬਹੁਤ ਸਾਰੇ ਹੋਰ ਫੰਕਸ਼ਨ ਹਨ ਜੋ ਉਹਨਾਂ ਦੇ JavaScript ਹਮਰੁਤਬਾ ਦੇ ਸਮਾਨ ਕੰਮ ਕਰਦੇ ਹਨ — ਜਾਂ ਮੂਲ ਰੂਪ ਵਿੱਚ ਕਿਸੇ ਵੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਵਿੱਚ ਹਮਰੁਤਬਾ — ਜੋ ਤੁਹਾਨੂੰ ਸ਼ਾਇਦ ਲਾਭਦਾਇਕ ਵੀ ਲੱਗੇਗਾ, ਜਿਵੇਂ ਕਿ ਫਲੋਰ, ਛੱਤ, ਗੋਲ, ਜੋੜ, ਅਤੇ ਹੋਰ। ਹੇਠਾਂ ਦਿੱਤਾ ਡੈਮੋ ਇਹਨਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਫੰਕਸ਼ਨ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ: ਬ੍ਰਾਇਨ ਰਾਸਮੁਸੇਨ ਦੁਆਰਾ ਪੇਨ ਐਕਸਪਾਥ ਸੰਖਿਆਤਮਕ ਫੰਕਸ਼ਨਾਂ [ਫੋਰਕਡ] ਦੇਖੋ। ਨੋਟ ਕਰੋ ਕਿ, ਜ਼ਿਆਦਾਤਰ ਸਟ੍ਰਿੰਗ ਹੇਰਾਫੇਰੀ ਫੰਕਸ਼ਨਾਂ ਦੀ ਤਰ੍ਹਾਂ, ਬਹੁਤ ਸਾਰੇ ਸੰਖਿਆਤਮਕ ਇੱਕ ਸਿੰਗਲ ਇਨਪੁਟ ਲੈਂਦੇ ਹਨ। ਇਹ, ਬੇਸ਼ਕ, ਕਿਉਂਕਿ ਉਹਨਾਂ ਨੂੰ ਪੁੱਛਗਿੱਛ ਲਈ ਵਰਤਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਆਖਰੀ XPath ਉਦਾਹਰਨ ਵਿੱਚ: //li[floor(text()) > 250]/@val
ਜੇ ਤੁਸੀਂ ਉਹਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਜਿਵੇਂ ਕਿ ਜ਼ਿਆਦਾਤਰ ਉਦਾਹਰਣਾਂ ਕਰਦੀਆਂ ਹਨ, ਤਾਂ ਤੁਸੀਂ ਇਸਨੂੰ ਪਹਿਲੇ ਨੋਡ 'ਤੇ ਚਲਾਓਗੇ ਜੋ ਮਾਰਗ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਇੱਥੇ ਕੁਝ ਕਿਸਮ ਦੇ ਪਰਿਵਰਤਨ ਫੰਕਸ਼ਨ ਵੀ ਹਨ ਜਿਨ੍ਹਾਂ ਤੋਂ ਤੁਹਾਨੂੰ ਬਚਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿਉਂਕਿ JavaScript ਦੀ ਪਹਿਲਾਂ ਹੀ ਆਪਣੀ ਕਿਸਮ ਦੀ ਪਰਿਵਰਤਨ ਸਮੱਸਿਆਵਾਂ ਹਨ। ਪਰ ਕਈ ਵਾਰ ਅਜਿਹਾ ਹੋ ਸਕਦਾ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਕਿਸੇ ਸਟ੍ਰਿੰਗ ਨੂੰ ਕਿਸੇ ਹੋਰ ਸੰਖਿਆ ਦੇ ਵਿਰੁੱਧ ਚੈੱਕ ਕਰਨ ਲਈ ਇੱਕ ਨੰਬਰ ਵਿੱਚ ਬਦਲਣਾ ਚਾਹੁੰਦੇ ਹੋ। ਫੰਕਸ਼ਨ ਜੋ ਕਿਸੇ ਚੀਜ਼ ਦੀ ਕਿਸਮ ਨੂੰ ਸੈੱਟ ਕਰਦੇ ਹਨ ਬੁਲੀਅਨ, ਨੰਬਰ, ਸਟ੍ਰਿੰਗ ਅਤੇ ਨੋਡ ਹਨ। ਇਹ ਮਹੱਤਵਪੂਰਨ XPath ਡਾਟਾਟਾਈਪ ਹਨ। ਅਤੇ ਜਿਵੇਂ ਤੁਸੀਂ ਕਲਪਨਾ ਕਰ ਸਕਦੇ ਹੋ, ਇਹਨਾਂ ਵਿੱਚੋਂ ਜ਼ਿਆਦਾਤਰ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਡੇਟਾਟਾਈਪਾਂ 'ਤੇ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜੋ DOM ਨੋਡ ਨਹੀਂ ਹਨ। ਉਦਾਹਰਨ ਲਈ, substring-after ਇੱਕ ਸਟ੍ਰਿੰਗ ਲੈਂਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਪਹਿਲਾਂ ਹੀ ਕਵਰ ਕੀਤਾ ਹੈ, ਪਰ ਇਹ ਇੱਕ href ਵਿਸ਼ੇਸ਼ਤਾ ਤੋਂ ਸਤਰ ਹੋ ਸਕਦਾ ਹੈ। ਇਹ ਸਿਰਫ਼ ਇੱਕ ਸਤਰ ਵੀ ਹੋ ਸਕਦਾ ਹੈ:
const testSubstringAfter = document.queryXPaths("substring-after('hello world',' ')");
ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ, ਇਹ ਉਦਾਹਰਨ ਸਾਨੂੰ ["ਵਿਸ਼ਵ"] ਦੇ ਰੂਪ ਵਿੱਚ ਨਤੀਜਿਆਂ ਦੀ ਲੜੀ ਵਾਪਸ ਦੇਵੇਗੀ। ਇਸ ਨੂੰ ਕਾਰਵਾਈ ਵਿੱਚ ਦਿਖਾਉਣ ਲਈ, ਮੈਂ ਉਹਨਾਂ ਚੀਜ਼ਾਂ ਦੇ ਵਿਰੁੱਧ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਡੈਮੋ ਪੇਜ ਬਣਾਇਆ ਹੈ ਜੋ DOM ਨੋਡ ਨਹੀਂ ਹਨ: Bryan Rasmussen ਦੁਆਰਾ Pen queryXPath [forked] ਦੇਖੋ। ਤੁਹਾਨੂੰ ਟ੍ਰਾਂਸਲੇਟ ਫੰਕਸ਼ਨ ਦੇ ਹੈਰਾਨੀਜਨਕ ਪਹਿਲੂ ਨੂੰ ਨੋਟ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ, ਜੋ ਕਿ ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਦੂਜੇ ਆਰਗੂਮੈਂਟ ਵਿੱਚ ਇੱਕ ਅੱਖਰ ਹੈ (ਜਿਵੇਂ ਕਿ ਅੱਖਰਾਂ ਦੀ ਸੂਚੀ ਜਿਸ ਦਾ ਤੁਸੀਂ ਅਨੁਵਾਦ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ) ਅਤੇ ਅਨੁਵਾਦ ਕਰਨ ਲਈ ਕੋਈ ਮੇਲ ਖਾਂਦਾ ਅੱਖਰ ਨਹੀਂ ਹੈ, ਤਾਂ ਉਹ ਅੱਖਰ ਆਉਟਪੁੱਟ ਤੋਂ ਹਟਾ ਦਿੱਤਾ ਜਾਵੇਗਾ। ਇਸ ਤਰ੍ਹਾਂ, ਇਹ:
ਅਨੁਵਾਦ ਕਰੋ ('ਹੈਲੋ, ਮੇਰਾ ਨਾਮ ਇਨੀਗੋ ਮੋਂਟੋਆ ਹੈ, ਤੁਸੀਂ ਮੇਰੇ ਪਿਤਾ ਨੂੰ ਮਾਰ ਦਿੱਤਾ, ਮਰਨ ਦੀ ਤਿਆਰੀ','abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ,','*')
…ਸਤਰ ਵਿੱਚ ਨਤੀਜੇ, ਖਾਲੀ ਥਾਂਵਾਂ ਸਮੇਤ: ["*****"]
ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਅੱਖਰ “a” ਦਾ ਅਨੁਵਾਦ ਇੱਕ ਤਾਰੇ (*) ਵਿੱਚ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ, ਪਰ ਹਰ ਦੂਜੇ ਅੱਖਰ ਜਿਸਦਾ ਅਨੁਵਾਦ ਨਹੀਂ ਹੈ, ਨੂੰ ਟਾਰਗੇਟ ਸਤਰ ਦੇ ਕਾਰਨ ਪੂਰੀ ਤਰ੍ਹਾਂ ਹਟਾ ਦਿੱਤਾ ਗਿਆ ਹੈ। ਵ੍ਹਾਈਟਸਪੇਸ ਸਾਡੇ ਕੋਲ ਬਾਕੀ ਬਚੀ ਹੈਅਨੁਵਾਦ ਕੀਤੇ "a" ਅੱਖਰਾਂ ਦੇ ਵਿਚਕਾਰ। ਫਿਰ ਦੁਬਾਰਾ, ਇਹ ਪੁੱਛਗਿੱਛ:
ਅਨੁਵਾਦ ਕਰੋ('ਹੈਲੋ, ਮੇਰਾ ਨਾਮ ਇਨੀਗੋ ਮੋਂਟੋਆ ਹੈ, ਤੁਸੀਂ ਮੇਰੇ ਪਿਤਾ ਨੂੰ ਮਾਰ ਦਿੱਤਾ, ਮਰਨ ਲਈ ਤਿਆਰ ਹੋ','abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ,','**************************************)
…ਇਸ ਵਿੱਚ ਕੋਈ ਸਮੱਸਿਆ ਨਹੀਂ ਹੈ ਅਤੇ ਅਜਿਹਾ ਨਤੀਜਾ ਨਿਕਲਦਾ ਹੈ ਜੋ ਇਸ ਤਰ੍ਹਾਂ ਦਿਸਦਾ ਹੈ:
"*******************************************************
ਇਹ ਤੁਹਾਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰ ਸਕਦਾ ਹੈ ਕਿ XPath ਅਨੁਵਾਦ ਫੰਕਸ਼ਨ ਬਿਲਕੁਲ ਉਹੀ ਕਰਨ ਦਾ ਕੋਈ ਆਸਾਨ ਤਰੀਕਾ ਨਹੀਂ ਹੈ ਜੋ XPath ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ, ਹਾਲਾਂਕਿ ਬਹੁਤ ਸਾਰੇ ਵਰਤੋਂ ਦੇ ਮਾਮਲਿਆਂ ਲਈ, ਰੈਗੂਲਰ ਸਮੀਕਰਨਾਂ ਨਾਲ ਬਦਲੋ, ਸਭ ਇਸ ਨੂੰ ਸੰਭਾਲ ਸਕਦਾ ਹੈ। ਤੁਸੀਂ ਉਹੀ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਜੋ ਮੈਂ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤਾ ਹੈ, ਪਰ ਇਹ ਸਭ ਤੋਂ ਅਨੁਕੂਲ ਹੈ ਜੇਕਰ ਤੁਸੀਂ ਸਿਰਫ ਸਤਰ ਦਾ ਅਨੁਵਾਦ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ। ਹੇਠਾਂ ਦਿੱਤਾ ਡੈਮੋ JavaScript ਸੰਸਕਰਣ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ XPath ਦੇ ਅਨੁਵਾਦ ਕਾਰਜ ਨੂੰ ਸਮੇਟਦਾ ਹੈ: ਬ੍ਰਾਇਨ ਰਾਸਮੁਸੇਨ ਦੁਆਰਾ ਪੇਨ ਅਨੁਵਾਦ ਫੰਕਸ਼ਨ [ਫੋਰਕਡ] ਦੇਖੋ। ਤੁਸੀਂ ਇਸ ਤਰ੍ਹਾਂ ਦੀ ਕੋਈ ਚੀਜ਼ ਕਿੱਥੇ ਵਰਤ ਸਕਦੇ ਹੋ? ਤਿੰਨ-ਸਥਾਨਾਂ ਦੇ ਔਫਸੈੱਟ ਦੇ ਨਾਲ ਸੀਜ਼ਰ ਸਿਫਰ ਐਨਕ੍ਰਿਪਸ਼ਨ 'ਤੇ ਵਿਚਾਰ ਕਰੋ (ਉਦਾਹਰਣ ਵਜੋਂ, 48 ਬੀ.ਸੀ. ਤੋਂ ਟਾਪ-ਆਫ-ਦੀ-ਲਾਈਨ ਐਨਕ੍ਰਿਪਸ਼ਨ):
ਅਨੁਵਾਦ ਕਰੋ("ਸੀਜ਼ਰ ਰੁਬੀਕਨ ਨੂੰ ਪਾਰ ਕਰਨ ਦੀ ਯੋਜਨਾ ਬਣਾ ਰਿਹਾ ਹੈ!", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", "XYZABCDEFGHIJKLMNOPQRSTUVWxyzabcdefghijklmnopqrstuvw")
ਇਨਪੁਟ ਟੈਕਸਟ "ਸੀਜ਼ਰ ਰੁਬੀਕਨ ਨੂੰ ਪਾਰ ਕਰਨ ਦੀ ਯੋਜਨਾ ਬਣਾ ਰਿਹਾ ਹੈ!" ਨਤੀਜੇ "Zxbpxo fp mixkkfkd ql zolpp qeb Oryfzlk!" ਵੱਖ-ਵੱਖ ਸੰਭਾਵਨਾਵਾਂ ਦੀ ਇੱਕ ਹੋਰ ਤੇਜ਼ ਉਦਾਹਰਨ ਦੇਣ ਲਈ, ਮੈਂ ਇੱਕ ਮੈਟਲ ਫੰਕਸ਼ਨ ਬਣਾਇਆ ਹੈ ਜੋ ਇੱਕ ਸਟ੍ਰਿੰਗ ਇਨਪੁਟ ਲੈਂਦਾ ਹੈ ਅਤੇ ਟੈਕਸਟ ਨੂੰ ਵਾਪਸ ਕਰਨ ਲਈ ਇੱਕ ਅਨੁਵਾਦ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਸਾਰੇ ਅੱਖਰ ਸ਼ਾਮਲ ਹਨ ਜੋ umlauts ਲੈਂਦੇ ਹਨ। ਬ੍ਰਾਇਨ ਰਾਸਮੁਸੇਨ ਦੁਆਰਾ ਪੇਨ ਮੈਟਲ ਫੰਕਸ਼ਨ [ਫੋਰਕਡ] ਦੇਖੋ।
const metal = (str) => { ਵਾਪਸੀ ਅਨੁਵਾਦ(str, "AOUaou","ÄÖÜäöü"); }
ਅਤੇ, ਜੇ "ਮੋਟਲੇ ਕਰੂ ਨਿਯਮ, ਡੂਡਜ਼ 'ਤੇ ਰੌਕ!" ਟੈਕਸਟ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ "ਮੋਟਲੇ ਕ੍ਰੂ ਰੂਲਜ਼, ਰੌਕ ਓਨ ਡੂਡਸ!" ਵਾਪਸ ਆਉਂਦਾ ਹੈ। ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ, ਕਿਸੇ ਕੋਲ ਇਸ ਫੰਕਸ਼ਨ ਦੀਆਂ ਸਾਰੀਆਂ ਕਿਸਮਾਂ ਦੀਆਂ ਪੈਰੋਡੀ ਵਰਤੋਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਜੇ ਇਹ ਤੁਸੀਂ ਹੋ, ਤਾਂ ਇਹ TVTropes ਲੇਖ ਤੁਹਾਨੂੰ ਬਹੁਤ ਸਾਰੀ ਪ੍ਰੇਰਨਾ ਪ੍ਰਦਾਨ ਕਰੇਗਾ। XPath ਨਾਲ CSS ਦੀ ਵਰਤੋਂ ਕਰਨਾ XPath ਦੇ ਨਾਲ CSS ਚੋਣਕਾਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਸਾਡੇ ਮੁੱਖ ਕਾਰਨ ਨੂੰ ਯਾਦ ਰੱਖੋ: CSS ਬਹੁਤ ਜ਼ਿਆਦਾ ਸਮਝਦਾ ਹੈ ਕਿ ਇੱਕ ਕਲਾਸ ਕੀ ਹੈ, ਜਦੋਂ ਕਿ ਤੁਸੀਂ XPath ਨਾਲ ਸਭ ਤੋਂ ਵਧੀਆ ਕਰ ਸਕਦੇ ਹੋ ਕਲਾਸ ਗੁਣ ਦੀ ਸਟ੍ਰਿੰਗ ਤੁਲਨਾ। ਇਹ ਜ਼ਿਆਦਾਤਰ ਮਾਮਲਿਆਂ ਵਿੱਚ ਕੰਮ ਕਰੇਗਾ। ਪਰ ਜੇਕਰ ਤੁਸੀਂ ਕਦੇ ਅਜਿਹੀ ਸਥਿਤੀ ਵਿੱਚ ਚਲੇ ਜਾਂਦੇ ਹੋ ਜਿੱਥੇ, ਕਹੋ, ਕਿਸੇ ਨੇ .primaryLinks ਅਤੇ .primaryLinks2 ਨਾਮ ਦੀਆਂ ਕਲਾਸਾਂ ਬਣਾਈਆਂ ਹਨ ਅਤੇ ਤੁਸੀਂ .primaryLinks ਕਲਾਸ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ XPath ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਸਮੱਸਿਆਵਾਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪਵੇਗਾ। ਜਿੰਨਾ ਚਿਰ ਇਸ ਤਰ੍ਹਾਂ ਦੀ ਕੋਈ ਮੂਰਖਤਾ ਨਹੀਂ ਹੈ, ਤੁਸੀਂ ਸ਼ਾਇਦ XPath ਦੀ ਵਰਤੋਂ ਕਰੋਗੇ। ਪਰ ਮੈਨੂੰ ਇਹ ਦੱਸ ਕੇ ਦੁੱਖ ਹੋ ਰਿਹਾ ਹੈ ਕਿ ਮੈਂ ਉਨ੍ਹਾਂ ਥਾਵਾਂ 'ਤੇ ਕੰਮ ਕੀਤਾ ਹੈ ਜਿੱਥੇ ਲੋਕ ਇਸ ਤਰ੍ਹਾਂ ਦੀਆਂ ਮੂਰਖਤਾ ਭਰੀਆਂ ਗੱਲਾਂ ਕਰਦੇ ਹਨ। CSS ਅਤੇ XPath ਨੂੰ ਇਕੱਠੇ ਵਰਤਦੇ ਹੋਏ ਇੱਥੇ ਇੱਕ ਹੋਰ ਡੈਮੋ ਹੈ। ਇਹ ਦਿਖਾਉਂਦਾ ਹੈ ਕਿ ਕੀ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਅਸੀਂ ਇੱਕ ਸੰਦਰਭ ਨੋਡ 'ਤੇ XPath ਨੂੰ ਚਲਾਉਣ ਲਈ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਜੋ ਦਸਤਾਵੇਜ਼ ਦਾ ਨੋਡ ਨਹੀਂ ਹੈ। Bryan Rasmussen ਦੁਆਰਾ ਪੇਨ css ਅਤੇ xpath ਨੂੰ ਇਕੱਠੇ ਵੇਖੋ। CSS ਕਿਊਰੀ .relatedarticles a ਹੈ, ਜੋ ਕਿ .relatedarticles ਕਲਾਸ ਨੂੰ ਨਿਰਧਾਰਤ ਕੀਤੀ div ਵਿੱਚ ਦੋ ਤੱਤਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਦੀ ਹੈ। ਉਸ ਤੋਂ ਬਾਅਦ ਤਿੰਨ "ਬੁਰੇ" ਸਵਾਲ ਹਨ, ਮਤਲਬ ਕਿ, ਉਹ ਸਵਾਲ ਜੋ ਉਹ ਨਹੀਂ ਕਰਦੇ ਜੋ ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ ਜਦੋਂ ਇਹਨਾਂ ਤੱਤਾਂ ਨਾਲ ਸੰਦਰਭ ਨੋਡ ਦੇ ਤੌਰ 'ਤੇ ਚੱਲਦੇ ਹਾਂ। ਮੈਂ ਦੱਸ ਸਕਦਾ ਹਾਂ ਕਿ ਉਹ ਤੁਹਾਡੀ ਉਮੀਦ ਨਾਲੋਂ ਵੱਖਰਾ ਵਿਹਾਰ ਕਿਉਂ ਕਰ ਰਹੇ ਹਨ। ਸਵਾਲ ਵਿੱਚ ਤਿੰਨ ਮਾੜੇ ਸਵਾਲ ਹਨ:
//text(): ਦਸਤਾਵੇਜ਼ ਵਿੱਚ ਸਾਰਾ ਟੈਕਸਟ ਵਾਪਸ ਕਰਦਾ ਹੈ। //a/text(): ਦਸਤਾਵੇਜ਼ ਵਿਚਲੇ ਲਿੰਕਾਂ ਦੇ ਅੰਦਰਲੇ ਸਾਰੇ ਟੈਕਸਟ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ। ./a/text(): ਕੋਈ ਨਤੀਜਾ ਨਹੀਂ ਦਿੰਦਾ।
ਇਹਨਾਂ ਨਤੀਜਿਆਂ ਦਾ ਕਾਰਨ ਇਹ ਹੈ ਕਿ ਜਦੋਂ ਕਿ ਤੁਹਾਡਾ ਸੰਦਰਭ CSS ਪੁੱਛਗਿੱਛ ਤੋਂ ਵਾਪਸ ਕੀਤੇ ਗਏ ਤੱਤ ਹਨ, // ਪੂਰੇ ਦਸਤਾਵੇਜ਼ ਦੇ ਵਿਰੁੱਧ ਜਾਂਦਾ ਹੈ. ਇਹ XPath ਦੀ ਤਾਕਤ ਹੈ; CSS ਇੱਕ ਨੋਡ ਤੋਂ ਇੱਕ ਪੂਰਵਜ ਤੱਕ ਅਤੇ ਫਿਰ ਉਸ ਪੂਰਵਜ ਦੇ ਇੱਕ ਭੈਣ-ਭਰਾ ਤੱਕ ਨਹੀਂ ਜਾ ਸਕਦਾ, ਅਤੇ ਉਸ ਭੈਣ-ਭਰਾ ਦੇ ਵੰਸ਼ ਤੱਕ ਨਹੀਂ ਜਾ ਸਕਦਾ। ਪਰ XPath ਕਰ ਸਕਦਾ ਹੈ। ਇਸ ਦੌਰਾਨ, ./ ਮੌਜੂਦਾ ਨੋਡ ਦੇ ਬੱਚਿਆਂ ਨੂੰ ਪੁੱਛਦਾ ਹੈ, ਜਿੱਥੇ ਬਿੰਦੂ (.) ਮੌਜੂਦਾ ਨੋਡ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ, ਅਤੇ ਫਾਰਵਰਡ ਸਲੈਸ਼ (/) ਕੁਝ ਚਾਈਲਡ ਨੋਡ 'ਤੇ ਜਾਣ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ — ਭਾਵੇਂ ਇਹ ਕੋਈ ਗੁਣ, ਤੱਤ, ਜਾਂ ਟੈਕਸਟ ਮਾਰਗ ਦੇ ਅਗਲੇ ਹਿੱਸੇ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਪਰ CSS ਪੁੱਛਗਿੱਛ ਦੁਆਰਾ ਚੁਣਿਆ ਗਿਆ ਕੋਈ ਵੀ ਚਾਈਲਡ ਐਲੀਮੈਂਟ ਨਹੀਂ ਹੈ, ਇਸ ਤਰ੍ਹਾਂ ਉਹ ਪੁੱਛਗਿੱਛ ਵੀ ਕੁਝ ਨਹੀਂ ਦਿੰਦੀ। ਉਸ ਆਖਰੀ ਡੈਮੋ ਵਿੱਚ ਤਿੰਨ ਚੰਗੇ ਸਵਾਲ ਹਨ:
.//text(), ./text(), ਸਧਾਰਣ-ਸਪੇਸ(./text())।
ਸਧਾਰਣ-ਸਪੇਸ ਪੁੱਛਗਿੱਛ XPath ਫੰਕਸ਼ਨ ਵਰਤੋਂ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ, ਪਰ ਦੂਜੀਆਂ ਪੁੱਛਗਿੱਛਾਂ ਵਿੱਚ ਸ਼ਾਮਲ ਸਮੱਸਿਆ ਨੂੰ ਵੀ ਹੱਲ ਕਰਦੀ ਹੈ। HTML ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਬਣਾਇਆ ਗਿਆ ਹੈ:
ਸੇਲੇਨਿਅਮ ਵੈਬਡ੍ਰਾਈਵਰ ਨਾਲ ਤੁਹਾਡੀ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਜਾਂਚ ਨੂੰ ਸਵੈਚਾਲਤ ਕਰਨਾ
ਪੁੱਛਗਿੱਛ ਟੈਕਸਟ ਨੋਡ ਦੇ ਸ਼ੁਰੂ ਅਤੇ ਅੰਤ ਵਿੱਚ ਇੱਕ ਲਾਈਨ ਫੀਡ ਵਾਪਸ ਕਰਦੀ ਹੈ,ਅਤੇ normalize-space ਇਸ ਨੂੰ ਹਟਾਉਂਦਾ ਹੈ। ਕਿਸੇ ਵੀ XPath ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਜੋ ਇੱਕ ਇਨਪੁਟ XPath ਨਾਲ ਬੂਲੀਅਨ ਤੋਂ ਇਲਾਵਾ ਕੁਝ ਹੋਰ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਦੂਜੇ ਫੰਕਸ਼ਨਾਂ 'ਤੇ ਲਾਗੂ ਹੁੰਦਾ ਹੈ। ਹੇਠਾਂ ਦਿੱਤਾ ਡੈਮੋ ਕਈ ਉਦਾਹਰਣਾਂ ਦਿਖਾਉਂਦਾ ਹੈ: Bryan Rasmussen ਦੁਆਰਾ Pen xpath ਫੰਕਸ਼ਨਾਂ ਦੀਆਂ ਉਦਾਹਰਣਾਂ [forked] ਵੇਖੋ। ਪਹਿਲੀ ਉਦਾਹਰਨ ਇੱਕ ਸਮੱਸਿਆ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ ਜਿਸ ਲਈ ਤੁਹਾਨੂੰ ਧਿਆਨ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ। ਖਾਸ ਤੌਰ 'ਤੇ, ਹੇਠ ਦਿੱਤੇ ਕੋਡ:
document.queryXPaths("substring-after(//a/@href,'https://')");
…ਇੱਕ ਸਤਰ ਵਾਪਸ ਕਰਦਾ ਹੈ:
"www.smashingmagazine.com/2018/04/feature-testing-selenium-webdriver/"
ਇਹ ਅਰਥ ਰੱਖਦਾ ਹੈ, ਠੀਕ ਹੈ? ਇਹ ਫੰਕਸ਼ਨ ਐਰੇ ਵਾਪਸ ਨਹੀਂ ਕਰਦੇ ਸਗੋਂ ਸਿੰਗਲ ਸਤਰ ਜਾਂ ਸਿੰਗਲ ਨੰਬਰ ਦਿੰਦੇ ਹਨ। ਕਈ ਨਤੀਜਿਆਂ ਦੇ ਨਾਲ ਕਿਤੇ ਵੀ ਫੰਕਸ਼ਨ ਚਲਾਉਣਾ ਸਿਰਫ ਪਹਿਲਾ ਨਤੀਜਾ ਦਿੰਦਾ ਹੈ। ਦੂਜਾ ਨਤੀਜਾ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਅਸੀਂ ਅਸਲ ਵਿੱਚ ਕੀ ਚਾਹੁੰਦੇ ਹਾਂ:
document.queryCSSSelectors("a").queryXPaths("substring-after(./@href,'https://')");
ਜੋ ਦੋ ਸਤਰਾਂ ਦੀ ਇੱਕ ਐਰੇ ਵਾਪਸ ਕਰਦਾ ਹੈ:
["www.smashingmagazine.com/2018/04/feature-testing-selenium-webdriver/","www.smashingmagazine.com/2022/11/automated-test-results-improve-accessibility/"]
XPath ਫੰਕਸ਼ਨਾਂ ਨੂੰ JavaScript ਵਿੱਚ ਫੰਕਸ਼ਨਾਂ ਵਾਂਗ ਨੇਸਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਲਈ, ਜੇਕਰ ਅਸੀਂ ਸਮੈਸ਼ਿੰਗ ਮੈਗਜ਼ੀਨ URL ਬਣਤਰ ਨੂੰ ਜਾਣਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਕੰਮ ਕਰ ਸਕਦੇ ਹਾਂ (ਟੈਂਪਲੇਟ ਲਿਟਰਲ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ): `ਅਨੁਵਾਦ( ਸਬਸਟਰਿੰਗ( substring-after(./@href, 'www.smashingmagazine.com/') ,9), '/', '')''
ਇਹ ਇਸ ਹੱਦ ਤੱਕ ਥੋੜਾ ਬਹੁਤ ਗੁੰਝਲਦਾਰ ਹੋ ਰਿਹਾ ਹੈ ਕਿ ਇਸ ਨੂੰ ਇਹ ਦੱਸਣ ਲਈ ਟਿੱਪਣੀਆਂ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਕਿ ਇਹ ਕੀ ਕਰਦਾ ਹੈ: www.smashingmagazine.com/ ਤੋਂ ਬਾਅਦ href ਵਿਸ਼ੇਸ਼ਤਾ ਤੋਂ ਸਾਰੇ URL ਲਓ, ਪਹਿਲੇ ਨੌ ਅੱਖਰਾਂ ਨੂੰ ਹਟਾਓ, ਫਿਰ ਫਾਰਵਰਡ ਸਲੈਸ਼ (/) ਅੱਖਰ ਦਾ ਅਨੁਵਾਦ ਕਰੋ ਤਾਂ ਜੋ ਅੰਤ ਵਾਲੇ ਫਾਰਵਰਡ ਸਲੈਸ਼ ਤੋਂ ਛੁਟਕਾਰਾ ਪਾਇਆ ਜਾ ਸਕੇ। ਨਤੀਜਾ ਐਰੇ:
["ਵਿਸ਼ੇਸ਼ਤਾ-ਟੈਸਟਿੰਗ-ਸੇਲੇਨਿਅਮ-ਵੈਬਡ੍ਰਾਈਵਰ","ਆਟੋਮੈਟਿਕ-ਟੈਸਟ-ਨਤੀਜੇ-ਸੁਧਾਰ-ਪਹੁੰਚਯੋਗਤਾ"]
ਹੋਰ XPath ਵਰਤੋਂ ਦੇ ਕੇਸ XPath ਅਸਲ ਵਿੱਚ ਟੈਸਟਿੰਗ ਵਿੱਚ ਚਮਕ ਸਕਦਾ ਹੈ। ਕਾਰਨ ਨੂੰ ਦੇਖਣਾ ਮੁਸ਼ਕਲ ਨਹੀਂ ਹੈ, ਕਿਉਂਕਿ XPath ਨੂੰ DOM ਵਿੱਚ ਹਰੇਕ ਤੱਤ ਨੂੰ DOM ਵਿੱਚ ਕਿਸੇ ਵੀ ਸਥਿਤੀ ਤੋਂ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਜਦੋਂ ਕਿ CSS ਨਹੀਂ ਕਰ ਸਕਦਾ। ਤੁਸੀਂ ਬਹੁਤ ਸਾਰੇ ਆਧੁਨਿਕ ਬਿਲਡ ਸਿਸਟਮਾਂ ਵਿੱਚ ਇੱਕਸਾਰ ਰਹਿਣ ਵਾਲੀਆਂ CSS ਕਲਾਸਾਂ 'ਤੇ ਭਰੋਸਾ ਨਹੀਂ ਕਰ ਸਕਦੇ, ਪਰ XPath ਦੇ ਨਾਲ, ਅਸੀਂ ਇੱਕ ਤੱਤ ਦੀ ਟੈਕਸਟ ਸਮੱਗਰੀ ਕੀ ਹੈ, ਇੱਕ ਬਦਲਦੇ DOM ਢਾਂਚੇ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ, ਹੋਰ ਮਜ਼ਬੂਤ ਮੇਲ ਬਣਾਉਣ ਦੇ ਯੋਗ ਹਾਂ। ਤਕਨੀਕਾਂ 'ਤੇ ਖੋਜ ਕੀਤੀ ਗਈ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਲਚਕੀਲੇ XPath ਟੈਸਟ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀਆਂ ਹਨ। ਟੈਸਟਾਂ ਦੇ ਬਾਹਰ ਆਉਣ ਅਤੇ ਅਸਫਲ ਹੋਣ ਨਾਲੋਂ ਕੁਝ ਵੀ ਮਾੜਾ ਨਹੀਂ ਹੈ ਕਿਉਂਕਿ ਇੱਕ CSS ਚੋਣਕਾਰ ਹੁਣ ਕੰਮ ਨਹੀਂ ਕਰਦਾ ਕਿਉਂਕਿ ਕਿਸੇ ਚੀਜ਼ ਦਾ ਨਾਮ ਬਦਲਿਆ ਜਾਂ ਹਟਾ ਦਿੱਤਾ ਗਿਆ ਹੈ। XPath ਮਲਟੀਪਲ ਲੋਕੇਟਰ ਕੱਢਣ 'ਤੇ ਵੀ ਬਹੁਤ ਵਧੀਆ ਹੈ। ਕਿਸੇ ਤੱਤ ਨਾਲ ਮੇਲ ਕਰਨ ਲਈ XPath ਪੁੱਛਗਿੱਛਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਇੱਕ ਤੋਂ ਵੱਧ ਤਰੀਕੇ ਹਨ। CSS ਨਾਲ ਵੀ ਇਹੀ ਸੱਚ ਹੈ। ਪਰ XPath ਪੁੱਛਗਿੱਛਾਂ ਚੀਜ਼ਾਂ ਨੂੰ ਵਧੇਰੇ ਨਿਯਤ ਤਰੀਕੇ ਨਾਲ ਡ੍ਰਿਲ ਕਰ ਸਕਦੀਆਂ ਹਨ ਜੋ ਕਿ ਵਾਪਸ ਪ੍ਰਾਪਤ ਹੋਣ ਵਾਲੀਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਸੀਮਤ ਕਰਦੀਆਂ ਹਨ, ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਇੱਕ ਖਾਸ ਮੈਚ ਲੱਭ ਸਕਦੇ ਹੋ ਜਿੱਥੇ ਕਈ ਸੰਭਾਵਿਤ ਮੈਚ ਹੋ ਸਕਦੇ ਹਨ। ਉਦਾਹਰਨ ਲਈ, ਅਸੀਂ ਇੱਕ ਖਾਸ h2 ਐਲੀਮੈਂਟ ਨੂੰ ਵਾਪਸ ਕਰਨ ਲਈ XPath ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ ਜੋ ਇੱਕ div ਦੇ ਅੰਦਰ ਮੌਜੂਦ ਹੈ ਜੋ ਤੁਰੰਤ ਇੱਕ sibling div ਦਾ ਅਨੁਸਰਣ ਕਰਦਾ ਹੈ, ਜੋ ਬਦਲੇ ਵਿੱਚ, ਇੱਕ data-testID="leader" ਗੁਣ ਦੇ ਨਾਲ ਇੱਕ ਚਾਈਲਡ ਚਿੱਤਰ ਤੱਤ ਰੱਖਦਾ ਹੈ:
ਇਹ ਸੁਰਖੀ ਪ੍ਰਾਪਤ ਨਾ ਕਰੋ
ਇਹ ਸਿਰਲੇਖ ਵੀ ਨਾ ਪ੍ਰਾਪਤ ਕਰੋ
ਲੀਡਰ ਚਿੱਤਰ ਲਈ ਸਿਰਲੇਖ
ਇਹ ਪੁੱਛਗਿੱਛ ਹੈ: document.queryXPaths(` //div[ ਨਿਮਨਲਿਖਤ-ਭਾਈ::div[1] /img[@data-testID='ਲੀਡਰ'] ] /h2/ ਟੈਕਸਟ() `);
ਆਉ ਇਹ ਦੇਖਣ ਲਈ ਇੱਕ ਡੈਮੋ ਵਿੱਚ ਸੁੱਟੀਏ ਕਿ ਇਹ ਸਭ ਕਿਵੇਂ ਇਕੱਠੇ ਹੁੰਦਾ ਹੈ: Bryan Rasmussen ਦੁਆਰਾ Pen Complex H2 ਪੁੱਛਗਿੱਛ [forked] ਦੇਖੋ। ਇਸ ਲਈ, ਹਾਂ. XPath ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਟੈਸਟ ਵਿੱਚ ਕਿਸੇ ਵੀ ਤੱਤ ਲਈ ਬਹੁਤ ਸਾਰੇ ਸੰਭਵ ਮਾਰਗ ਹਨ। XSLT 1.0 ਬਰਤਰਫ਼ ਮੈਂ ਪਹਿਲਾਂ ਜ਼ਿਕਰ ਕੀਤਾ ਸੀ ਕਿ Chrome ਟੀਮ ਬ੍ਰਾਊਜ਼ਰ ਤੋਂ XSLT 1.0 ਸਮਰਥਨ ਨੂੰ ਹਟਾਉਣ ਦੀ ਯੋਜਨਾ ਬਣਾ ਰਹੀ ਹੈ। ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ XSLT 1.0 ਦਸਤਾਵੇਜ਼ ਪਰਿਵਰਤਨ ਲਈ XML- ਕੇਂਦਰਿਤ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਜੋ ਬਦਲੇ ਵਿੱਚ, XPath 1.0 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ ਜ਼ਿਆਦਾਤਰ ਬ੍ਰਾਊਜ਼ਰਾਂ ਵਿੱਚ ਪਾਇਆ ਜਾਂਦਾ ਹੈ। ਜਦੋਂ ਅਜਿਹਾ ਹੁੰਦਾ ਹੈ, ਅਸੀਂ XPath ਦਾ ਇੱਕ ਮੁੱਖ ਭਾਗ ਗੁਆ ਦੇਵਾਂਗੇ। ਪਰ ਇਸ ਤੱਥ ਦੇ ਮੱਦੇਨਜ਼ਰ ਕਿ XPath ਟੈਸਟਾਂ ਨੂੰ ਲਿਖਣ ਲਈ ਸੱਚਮੁੱਚ ਬਹੁਤ ਵਧੀਆ ਹੈ, ਮੈਨੂੰ ਇਹ ਸੰਭਾਵਨਾ ਨਹੀਂ ਹੈ ਕਿ ਸਮੁੱਚੇ ਤੌਰ 'ਤੇ XPath ਕਿਸੇ ਵੀ ਸਮੇਂ ਜਲਦੀ ਹੀ ਅਲੋਪ ਹੋ ਜਾਵੇਗਾ. ਉਸ ਨੇ ਕਿਹਾ, ਮੈਂ ਦੇਖਿਆ ਹੈ ਕਿ ਜਦੋਂ ਕਿਸੇ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਹਟਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਲੋਕ ਉਸ ਵਿੱਚ ਦਿਲਚਸਪੀ ਲੈਂਦੇ ਹਨ। ਅਤੇ ਇਹ XSLT 1.0 ਨੂੰ ਬਰਤਰਫ਼ ਕੀਤੇ ਜਾਣ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਨਿਸ਼ਚਤ ਤੌਰ 'ਤੇ ਸੱਚ ਹੈ। ਬਰਤਾਨੀਆ ਦੇ ਵਿਰੁੱਧ ਦਲੀਲਾਂ ਨਾਲ ਭਰੀ ਹੈਕਰ ਨਿਊਜ਼ 'ਤੇ ਪੂਰੀ ਚਰਚਾ ਹੋ ਰਹੀ ਹੈ। ਪੋਸਟ ਖੁਦ XSLT ਨਾਲ ਬਲੌਗਿੰਗ ਫਰੇਮਵਰਕ ਬਣਾਉਣ ਦਾ ਇੱਕ ਵਧੀਆ ਉਦਾਹਰਣ ਹੈ. ਤੁਹਾਨੂੰਆਪਣੇ ਲਈ ਚਰਚਾ ਨੂੰ ਪੜ੍ਹ ਸਕਦੇ ਹੋ, ਪਰ ਇਹ ਇਸ ਗੱਲ ਵਿੱਚ ਆਉਂਦਾ ਹੈ ਕਿ ਕਿਵੇਂ JavaScript ਨੂੰ XLST ਲਈ ਇੱਕ ਸ਼ਿਮ ਵਜੋਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ ਤਾਂ ਜੋ ਇਸ ਕਿਸਮ ਦੇ ਕੇਸਾਂ ਨੂੰ ਸੰਭਾਲਿਆ ਜਾ ਸਕੇ। ਮੈਂ ਇਹ ਸੁਝਾਅ ਵੀ ਦੇਖੇ ਹਨ ਕਿ ਬ੍ਰਾਊਜ਼ਰਾਂ ਨੂੰ SaxonJS ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਜੋ JavaScript ਦੇ Saxon XSLT, XQUERY, ਅਤੇ XPath ਇੰਜਣਾਂ ਲਈ ਇੱਕ ਪੋਰਟ ਹੈ। ਇਹ ਇੱਕ ਦਿਲਚਸਪ ਵਿਚਾਰ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਿਵੇਂ ਕਿ Saxon-JS ਇਹਨਾਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੇ ਮੌਜੂਦਾ ਸੰਸਕਰਣ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਇੱਥੇ ਕੋਈ ਵੀ ਬ੍ਰਾਊਜ਼ਰ ਨਹੀਂ ਹੈ ਜੋ XPath ਜਾਂ XSLT ਦੇ ਕਿਸੇ ਵੀ ਸੰਸਕਰਣ ਨੂੰ 1.0 ਤੋਂ ਅੱਗੇ ਲਾਗੂ ਕਰਦਾ ਹੈ, ਅਤੇ ਕੋਈ ਵੀ ਨਹੀਂ ਜੋ XQuery ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ। ਮੈਂ Saxonica ਵਿਖੇ Norm Tovey-Walsh, SaxonJS ਅਤੇ Saxon ਇੰਜਣ ਦੇ ਦੂਜੇ ਸੰਸਕਰਣਾਂ ਦੇ ਪਿੱਛੇ ਵਾਲੀ ਕੰਪਨੀ ਤੱਕ ਪਹੁੰਚ ਕੀਤੀ। ਉਸਨੇ ਕਿਹਾ: "ਜੇਕਰ ਕੋਈ ਬ੍ਰਾਊਜ਼ਰ ਵਿਕਰੇਤਾ SaxonJS ਨੂੰ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਆਧੁਨਿਕ XML ਤਕਨਾਲੋਜੀਆਂ ਨੂੰ ਏਕੀਕ੍ਰਿਤ ਕਰਨ ਲਈ ਇੱਕ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਵਜੋਂ ਲੈਣ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦਾ ਸੀ, ਤਾਂ ਅਸੀਂ ਉਹਨਾਂ ਨਾਲ ਇਸ ਬਾਰੇ ਚਰਚਾ ਕਰਨ ਲਈ ਬਹੁਤ ਖੁਸ਼ ਹੋਵਾਂਗੇ." - ਨੌਰਮ ਟੋਵੀ-ਵਾਲਸ਼
ਪਰ ਇਹ ਵੀ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ: "ਮੈਨੂੰ ਬਹੁਤ ਹੈਰਾਨੀ ਹੋਵੇਗੀ ਜੇਕਰ ਕੋਈ ਇਹ ਸੋਚਦਾ ਹੈ ਕਿ SaxonJS ਨੂੰ ਇਸਦੇ ਮੌਜੂਦਾ ਰੂਪ ਵਿੱਚ ਲੈਣਾ ਅਤੇ ਇਸਨੂੰ ਬ੍ਰਾਊਜ਼ਰ ਬਿਲਡ ਵਿੱਚ ਬਿਨਾਂ ਕਿਸੇ ਬਦਲਾਅ ਦੇ ਛੱਡਣਾ ਇੱਕ ਆਦਰਸ਼ ਪਹੁੰਚ ਹੋਵੇਗੀ। ਇੱਕ ਬ੍ਰਾਊਜ਼ਰ ਵਿਕਰੇਤਾ, ਇਸ ਤੱਥ ਦੇ ਕਾਰਨ ਕਿ ਉਹ ਬ੍ਰਾਊਜ਼ਰ ਬਣਾਉਂਦੇ ਹਨ, ਅਸੀਂ 'ਬਾਹਰੋਂ' ਕਰ ਸਕਦੇ ਹਾਂ ਨਾਲੋਂ ਬਹੁਤ ਡੂੰਘੇ ਪੱਧਰ 'ਤੇ ਏਕੀਕਰਣ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦੇ ਹਾਂ।"- ਨੌਰਮ ਟੋਵੀ-ਵਾਲਸ਼
ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ ਟੋਵੀ-ਵਾਲਸ਼ ਦੀਆਂ ਟਿੱਪਣੀਆਂ XSLT ਬਰਬਾਦੀ ਦੀ ਘੋਸ਼ਣਾ ਤੋਂ ਲਗਭਗ ਇੱਕ ਹਫ਼ਤਾ ਪਹਿਲਾਂ ਆਈਆਂ ਸਨ। ਸਿੱਟਾ ਮੈਂ ਤੇ ਜਾ ਸਕਦਾ ਸੀ। ਪਰ ਮੈਂ ਉਮੀਦ ਕਰਦਾ ਹਾਂ ਕਿ ਇਸ ਨੇ XPath ਦੀ ਸ਼ਕਤੀ ਦਾ ਪ੍ਰਦਰਸ਼ਨ ਕੀਤਾ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ ਬਹੁਤ ਸਾਰੀਆਂ ਉਦਾਹਰਣਾਂ ਦਿੱਤੀਆਂ ਹਨ ਜੋ ਇਹ ਦਰਸਾਉਂਦੀਆਂ ਹਨ ਕਿ ਮਹਾਨ ਚੀਜ਼ਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸਨੂੰ ਕਿਵੇਂ ਵਰਤਣਾ ਹੈ। ਇਹ ਬ੍ਰਾਊਜ਼ਰ ਸਟੈਕ ਵਿੱਚ ਪੁਰਾਣੀ ਟੈਕਨਾਲੋਜੀ ਦੀ ਇੱਕ ਸੰਪੂਰਨ ਉਦਾਹਰਣ ਹੈ ਜਿਸ ਵਿੱਚ ਅੱਜ ਵੀ ਬਹੁਤ ਸਾਰੀਆਂ ਉਪਯੋਗਤਾਵਾਂ ਹਨ, ਭਾਵੇਂ ਤੁਸੀਂ ਕਦੇ ਨਹੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ਇਹ ਮੌਜੂਦ ਹੈ ਜਾਂ ਕਦੇ ਵੀ ਇਸ ਤੱਕ ਪਹੁੰਚਣ ਬਾਰੇ ਨਹੀਂ ਸੋਚਿਆ ਹੈ। ਹੋਰ ਪੜ੍ਹਨਾ
“ਕੁਦਰਤੀ ਭਾਸ਼ਾ ਨਾਲ ਸਵੈਚਲਿਤ ਵੈੱਬ ਟੈਸਟਾਂ ਦੀ ਲਚਕਤਾ ਨੂੰ ਵਧਾਉਣਾ” (ACM ਡਿਜੀਟਲ ਲਾਇਬ੍ਰੇਰੀ) ਮਾਰੂਨ ਆਇਲੀ, ਯੂਸਫ਼ ਬਕਾਉਨੀ, ਨਾਦਰ ਜਾਲੋਲ, ਅਤੇ ਰੀਮਾ ਕਿਲਾਨੀ ਦੁਆਰਾ ਇਹ ਲੇਖ ਲਚਕੀਲੇ ਟੈਸਟਾਂ ਨੂੰ ਲਿਖਣ ਲਈ ਕਈ XPath ਉਦਾਹਰਨਾਂ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। XPath (MDN) ਜੇਕਰ ਤੁਸੀਂ XPath ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ ਬਾਰੇ ਤਕਨੀਕੀ ਵਿਆਖਿਆ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ਇਹ ਸ਼ੁਰੂਆਤ ਕਰਨ ਲਈ ਇੱਕ ਵਧੀਆ ਥਾਂ ਹੈ। XPath ਟਿਊਟੋਰਿਅਲ (ZVON)ਮੈਨੂੰ ਇਸ ਟਿਊਟੋਰਿਅਲ ਨੂੰ ਮੇਰੇ ਆਪਣੇ ਸਿੱਖਣ ਵਿੱਚ ਸਭ ਤੋਂ ਵੱਧ ਮਦਦਗਾਰ ਲੱਗਿਆ ਹੈ, ਬਹੁਤ ਸਾਰੀਆਂ ਉਦਾਹਰਣਾਂ ਅਤੇ ਸਪਸ਼ਟ ਵਿਆਖਿਆਵਾਂ ਦਾ ਧੰਨਵਾਦ। XPather ਇਹ ਇੰਟਰਐਕਟਿਵ ਟੂਲ ਤੁਹਾਨੂੰ ਸਿੱਧਾ ਕੋਡ ਨਾਲ ਕੰਮ ਕਰਨ ਦਿੰਦਾ ਹੈ।
