ਇਸ ਟੂਲ ਬਾਰੇ
JavaScript ਮਿਨੀਫੀਕੇਸ਼ਨ ਬੇਲੋੜੇ ਅੱਖਰਾਂ ਨੂੰ ਹਟਾ ਕੇ ਅਤੇ (ਸਹੀ ਮਿਨੀਫਾਇਰ ਦੇ ਨਾਲ) ਸਥਾਨਕ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਛੋਟੇ ਨਾਮਾਂ ਵਿੱਚ ਬਦਲ ਕੇ ਸਰੋਤ ਕੋਡ ਦਾ ਆਕਾਰ ਘਟਾਉਂਦਾ ਹੈ। ਪਹਿਲੀ ਸ਼੍ਰੇਣੀ - ਖਾਲੀ ਥਾਂ ਅਤੇ ਟਿੱਪਣੀ ਹਟਾਉਣ - ਸਿੱਧੀ ਅਤੇ ਜੋਖਮ-ਮੁਕਤ ਹੈ। ਦੂਜਾ — ਵੇਰੀਏਬਲ ਰੀਨਾਮਿੰਗ — ਲਈ ਸਕੋਪ ਨਿਯਮਾਂ ਨੂੰ ਸਮਝਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਅਤੇ ਇਹ ਉਹ ਹੈ ਜੋ ਉਤਪਾਦਨ ਮਿਨੀਫਾਇਰ ਜਿਵੇਂ ਕਿ Terser ਅਤੇ esbuild ਸਭ ਤੋਂ ਵਧੀਆ ਕਰਦੇ ਹਨ।
ਇਹ ਟੂਲ ਸੁਰੱਖਿਅਤ ਮਾਈਨੀਫਿਕੇਸ਼ਨ 'ਤੇ ਕੇਂਦ੍ਰਤ ਕਰਦਾ ਹੈ: ਟਿੱਪਣੀਆਂ ਨੂੰ ਉਤਾਰਨਾ, ਖਾਲੀ ਥਾਂ ਨੂੰ ਸਮੇਟਣਾ, ਬੇਲੋੜੇ ਸੈਮੀਕੋਲਨ ਨੂੰ ਹਟਾਉਣਾ, ਅਤੇ ਸਪੱਸ਼ਟ ਪੈਟਰਨਾਂ ਨੂੰ ਛੋਟਾ ਕਰਨਾ। ਵੇਰੀਏਬਲ ਰੀਨਾਮਿੰਗ ਰੂੜ੍ਹੀਵਾਦੀ ਹੈ — ਸਪਸ਼ਟ ਸਕੋਪਾਂ ਵਿੱਚ ਸਿਰਫ਼ ਸਥਾਨਕ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਛੋਹਿਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਬਾਹਰੀ ਤੌਰ 'ਤੇ ਹਵਾਲਾ ਦਿੱਤੇ ਨਾਮਾਂ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਨਤੀਜਾ ਕਾਰਜਸ਼ੀਲ ਤੌਰ 'ਤੇ ਸਰੋਤ ਦੇ ਸਮਾਨ ਹੈ।
ਪ੍ਰੋਡਕਸ਼ਨ-ਗ੍ਰੇਡ ਮਿਨੀਫਿਕੇਸ਼ਨ ਲਈ, ਸਮਰਪਿਤ ਟੂਲ (Terser, esbuild, swc) ਪੂਰੇ ECMAScript ਸਕੋਪ ਮਾਡਲ ਨੂੰ ਸਮਝਦੇ ਹਨ ਅਤੇ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਛੋਟਾ ਆਉਟਪੁੱਟ ਪੈਦਾ ਕਰਦੇ ਹਨ। ਇਹ ਟੂਲ ਤੇਜ਼ ਬ੍ਰਾਊਜ਼ਰ-ਸਾਈਡ ਮਿਨੀਫਿਕੇਸ਼ਨ ਲਈ ਹੈ ਜਦੋਂ ਪੂਰਾ ਬਿਲਡ ਸੈੱਟਅੱਪ ਉਪਲਬਧ ਨਹੀਂ ਹੁੰਦਾ ਹੈ।
JavaScript ਨੂੰ ਘੱਟ ਕਿਉਂ ਕਰੋ
JavaScript ਬੰਡਲ ਆਮ ਤੌਰ 'ਤੇ ਆਧੁਨਿਕ ਵੈੱਬਪੇਜ 'ਤੇ ਸਭ ਤੋਂ ਵੱਡਾ ਸਿੰਗਲ ਸਰੋਤ ਹੁੰਦੇ ਹਨ। ਮਿਨੀਫਿਕੇਸ਼ਨ ਨਿਯਮਿਤ ਤੌਰ 'ਤੇ ਅਣਮਿੱਥੇ ਸਰੋਤ ਦੇ ਮੁਕਾਬਲੇ 30-60% ਆਕਾਰ ਦੀ ਕਮੀ ਪੈਦਾ ਕਰਦਾ ਹੈ। gzip ਜਾਂ Brotli ਦੇ ਨਾਲ ਮਿਲਾ ਕੇ, ਕਟੌਤੀ ਕੁਝ ਹੱਦ ਤੱਕ ਸੁੰਗੜ ਜਾਂਦੀ ਹੈ, ਪਰ ਸੁਮੇਲ ਅਜੇ ਵੀ ਮਾਪਣਯੋਗ ਬਾਈਟਾਂ ਨੂੰ ਬਚਾਉਂਦਾ ਹੈ - ਖਾਸ ਤੌਰ 'ਤੇ ਹੌਲੀ ਕਨੈਕਸ਼ਨਾਂ ਵਾਲੇ ਉਪਭੋਗਤਾਵਾਂ ਲਈ।
ਤੇਜ਼ JavaScript ਦਾ ਮਤਲਬ ਇੰਟਰਐਕਟਿਵ ਲਈ ਤੇਜ਼ ਸਮਾਂ ਵੀ ਹੈ। ਛੋਟੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਤੇਜ਼ੀ ਨਾਲ ਡਾਉਨਲੋਡ ਹੁੰਦੀਆਂ ਹਨ, ਤੇਜ਼ੀ ਨਾਲ ਪਾਰਸ ਹੁੰਦੀਆਂ ਹਨ, ਅਤੇ ਜਲਦੀ ਲਾਗੂ ਹੁੰਦੀਆਂ ਹਨ। ਉਹਨਾਂ ਸਾਈਟਾਂ ਲਈ ਜਿੱਥੇ ਟੀਟੀਆਈ ਬਾਊਂਸ ਦਰਾਂ ਅਤੇ ਐਸਈਓ ਰੈਂਕਿੰਗ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੀ ਹੈ, ਮਿਨੀਫਿਕੇਸ਼ਨ ਉਪਲਬਧ ਸਭ ਤੋਂ ਸਸਤੀਆਂ ਜਿੱਤਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ।
ਤਕਨੀਕੀ ਵੇਰਵੇ
ਮਿਨੀਫਾਇਰ ਇੱਕ ਪਾਰਸਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ JavaScript ਨੂੰ ਟੋਕਨਾਈਜ਼ ਕਰਦਾ ਹੈ ਜੋ ECMAScript ਸੰਟੈਕਸ ਦਾ ਸਨਮਾਨ ਕਰਦਾ ਹੈ। ਟਿੱਪਣੀਆਂ (ਸਿੰਗਲ-ਲਾਈਨ ਅਤੇ ਮਲਟੀ-ਲਾਈਨ) /* ਨਾਲ ਚਿੰਨ੍ਹਿਤ ਲਾਇਸੈਂਸ ਟਿੱਪਣੀਆਂ ਨੂੰ ਛੱਡ ਕੇ ਹਟਾ ਦਿੱਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ! ਅਗੇਤਰ ਵ੍ਹਾਈਟਸਪੇਸ ਨੂੰ ਸਮੇਟਿਆ ਜਾਂਦਾ ਹੈ ਸਿਵਾਏ ਜਿੱਥੇ ਸਿੰਟੈਕਟਿਕ ਤੌਰ 'ਤੇ ਲੋੜ ਹੁੰਦੀ ਹੈ (ਪਛਾਣਕਰਤਾਵਾਂ ਦੇ ਵਿਚਕਾਰ, ਕੀਵਰਡਸ ਤੋਂ ਬਾਅਦ)।
ਕੰਜ਼ਰਵੇਟਿਵ ਵੇਰੀਏਬਲ ਦਾ ਨਾਮ ਬਦਲਣ ਨਾਲ ਸਥਾਨਕ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਸਿੱਧੇ ਸਕੋਪਾਂ ਵਿੱਚ ਛੋਟਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਗਲੋਬਲ, ਨਿਰਯਾਤ, ਅਤੇ ਆਯਾਤ ਕੀਤੇ ਨਾਵਾਂ ਦਾ ਨਾਮ ਬਦਲਿਆ ਨਹੀਂ ਗਿਆ ਹੈ - ਜੋ ਬਾਹਰੀ ਸੰਦਰਭਾਂ ਨੂੰ ਤੋੜ ਦੇਵੇਗਾ। ਡੂੰਘੇ ਨਾਮ ਬਦਲਣ ਲਈ, ਸਹੀ ਮੋਡੀਊਲ-ਜਾਗਰੂਕ ਵਿਸ਼ਲੇਸ਼ਣ ਦੇ ਨਾਲ Terser ਜਾਂ esbuild ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਕਿਨਾਰੇ ਦੇ ਕੇਸ: ਆਟੋਮੈਟਿਕ ਸੈਮੀਕੋਲਨ ਸੰਮਿਲਨ (ASI) ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਪ੍ਰੋਗਰਾਮ ਵਿਹਾਰ ਨੂੰ ਬਦਲਣ ਤੋਂ ਬਚਣ ਲਈ ਮਿਨੀਫਾਇਰ ਨੂੰ ਕੁਝ ਸੰਦਰਭਾਂ ਵਿੱਚ ਨਵੀਆਂ ਲਾਈਨਾਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ। ਟੈਮਪਲੇਟ ਲਿਟਰਲ, ਰੇਜੈਕਸ ਲਿਟਰਲ, ਅਤੇ JSX (ਜੇਕਰ ਇਨਪੁਟ ਵਿੱਚ ਇਹ ਸ਼ਾਮਲ ਹੈ) ਨੂੰ ਬਿਲਕੁਲ ਸੁਰੱਖਿਅਤ ਰੱਖਿਆ ਗਿਆ ਹੈ ਕਿਉਂਕਿ ਉਹਨਾਂ ਦੀ ਸਮੱਗਰੀ ਸੰਕੁਚਿਤ ਕਰਨ ਲਈ ਸੁਰੱਖਿਅਤ ਨਹੀਂ ਹੋ ਸਕਦੀ।
ਅਕਸਰ ਪੁੱਛੇ ਜਾਣ ਵਾਲੇ ਸਵਾਲ
- ਕੀ ਮਾਈਨੀਫਿਕੇਸ਼ਨ ਮੇਰੇ ਕੋਡ ਦੇ ਕੰਮ ਕਰਨ ਦੇ ਤਰੀਕੇ ਨੂੰ ਬਦਲਦਾ ਹੈ?
- ਸੰ. ਵੇਰੀਏਬਲ ਸ਼ਾਰਟਨਿੰਗ (ਮੈਂਗਲਿੰਗ) ਸਥਾਨਕ ਵੇਰੀਏਬਲਾਂ ਦਾ ਨਾਮ ਬਦਲਦਾ ਹੈ ਪਰ ਵਿਵਹਾਰ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਦਾ ਹੈ। ਗਲੋਬਲ ਵੇਰੀਏਬਲ ਅਤੇ ਨਿਰਯਾਤ ਨਾਮ ਬਰਕਰਾਰ ਰੱਖੇ ਗਏ ਹਨ.
- ਕੀ ਮੈਨੂੰ ਵਿਕਾਸ ਜਾਂ ਉਤਪਾਦਨ ਵਿੱਚ ਘੱਟ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ?
- ਉਤਪਾਦਨ ਵਿੱਚ ਸਿਰਫ਼ ਛੋਟੇ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਵਿਕਾਸ ਦੌਰਾਨ, ਮੂਲ ਪੜ੍ਹਨਯੋਗ ਕੋਡ ਰੱਖੋ। ਬਹੁਤੇ ਬਿਲਡ ਟੂਲ (ਵੈਬਪੈਕ, ਵਾਈਟ, ਐਸਬਿਲਡ) ਉਤਪਾਦਨ ਬਿਲਡ ਪ੍ਰਕਿਰਿਆ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਆਪਣੇ ਆਪ ਮਿਨੀਫੀਕੇਸ਼ਨ ਨੂੰ ਸੰਭਾਲਦੇ ਹਨ।
- ਮਿਨਫੀਕੇਸ਼ਨ ਅਤੇ ਓਫਸਕੇਸ਼ਨ ਵਿੱਚ ਕੀ ਅੰਤਰ ਹੈ?
- ਜੇਕਰ ਫਾਰਮੈਟ ਕੀਤਾ ਗਿਆ ਹੈ ਤਾਂ ਕੋਡ ਨੂੰ ਕਾਰਜਸ਼ੀਲ ਤੌਰ 'ਤੇ ਪੜ੍ਹਨਯੋਗ ਰੱਖਣ ਦੇ ਦੌਰਾਨ ਮਾਈਨੀਫਿਕੇਸ਼ਨ ਆਕਾਰ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ। ਰੁਕਾਵਟ ਜਾਣਬੁੱਝ ਕੇ ਕੋਡ ਨੂੰ ਸਮਝਣ ਵਿੱਚ ਮੁਸ਼ਕਲ ਬਣਾਉਂਦਾ ਹੈ (ਸਟ੍ਰਿੰਗ ਏਨਕੋਡਿੰਗ, ਕੰਟਰੋਲ ਫਲੋ ਫਲੈਟਿੰਗ)। ਇਹ ਸੰਦ ਆਕਾਰ ਘਟਾਉਣ 'ਤੇ ਕੇਂਦ੍ਰਤ ਕਰਦਾ ਹੈ, ਨਾ ਕਿ ਉਲਝਣ 'ਤੇ.
- ਮੈਨੂੰ ਕਿੰਨੀ ਆਕਾਰ ਘਟਾਉਣ ਦੀ ਉਮੀਦ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ?
- ਆਮ ਤੌਰ 'ਤੇ gzip ਤੋਂ ਪਹਿਲਾਂ 30-60%. ਲੰਬੇ ਵੇਰੀਏਬਲ ਨਾਮਾਂ ਦੇ ਨਾਲ ਚੰਗੀ ਤਰ੍ਹਾਂ ਟਿੱਪਣੀ ਕੀਤੀ ਕੋਡ ਸਭ ਤੋਂ ਵੱਡੀਆਂ ਕਟੌਤੀਆਂ ਨੂੰ ਵੇਖਦਾ ਹੈ. gzip ਕੰਪਰੈਸ਼ਨ ਦੇ ਨਾਲ ਮਿਲਾ ਕੇ, JavaScript ਫਾਈਲਾਂ ਅਕਸਰ ਮੂਲ ਸਰੋਤ ਨਾਲੋਂ 80-90% ਛੋਟੀਆਂ ਹੁੰਦੀਆਂ ਹਨ।
- ਕੀ ਮੇਰਾ ਕੋਡ ਸਰਵਰ 'ਤੇ ਅੱਪਲੋਡ ਕੀਤਾ ਗਿਆ ਹੈ?
- ਨਹੀਂ। ਮਿਨੀਫਾਇਰ ਤੁਹਾਡੇ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ ਚੱਲਦਾ ਹੈ।
- ਮੇਰੀ JavaScript ਕਿੰਨੀ ਛੋਟੀ ਹੋਵੇਗੀ?
- ਆਮ ਤੌਰ 'ਤੇ 30-60% ਦੀ ਕਮੀ। ਲੰਬੇ ਪਛਾਣਕਰਤਾਵਾਂ ਦੇ ਨਾਲ ਵੇਰੀਏਬਲ-ਭਾਰੀ ਕੋਡ ਵਧੇਰੇ ਸੰਕੁਚਿਤ ਕਰਦਾ ਹੈ; ਸਮੀਕਰਨ-ਭਾਰੀ ਕੋਡ ਘੱਟ ਸੰਕੁਚਿਤ ਕਰਦਾ ਹੈ।
- ਕੀ ਮੈਨੂੰ ਹੱਥਾਂ ਨਾਲ ਛੋਟਾ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ?
- ਕਦੇ ਨਹੀਂ। ਸਰੋਤ ਵਿੱਚ ਪੜ੍ਹਨਯੋਗ JavaScript ਬਣਾਈ ਰੱਖੋ। ਇੱਕ ਬਿਲਡ ਸਟੈਪ ਦੇ ਤੌਰ ਤੇ ਜਾਂ ਤੈਨਾਤੀ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਮਿਨੀਫਿਕੇਸ਼ਨ ਚਲਾਓ।
- ਕੀ ਇਹ TypeScript 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ?
- Tsc ਜਾਂ esbuild ਦੀ ਵਰਤੋਂ ਕਰਕੇ TypeScript ਨੂੰ ਪਹਿਲਾਂ JavaScript ਵਿੱਚ ਕੰਪਾਇਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇੱਕ ਵਾਰ ਕੰਪਾਇਲ ਹੋ ਜਾਣ ਤੇ, ਨਤੀਜੇ ਵਜੋਂ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਨੂੰ ਛੋਟਾ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।