Back to Question Center
0

PHP ਨਾਲ ਵੱਡੇ ਫਾਈਲਾਂ ਨੂੰ ਕਿਵੇਂ ਪੜ੍ਹਿਆ ਜਾਵੇ (ਤੁਹਾਡਾ ਸਰਵਰ ਮਾਰਨ ਤੋਂ ਬਿਨਾਂ) PHP ਨਾਲ ਵੱਡੇ ਫਾਈਲਾਂ ਨੂੰ ਕਿਵੇਂ ਪੜ੍ਹਿਆ ਜਾਵੇ (ਤੁਹਾਡਾ ਸਰਵਰ ਮਾਰਨ ਤੋਂ ਬਿਨਾਂ) ਸੰਬੰਧਿਤ ਵਿਸ਼ਿਆਂ: ਡ੍ਰਪਲਲ ਵਿਕਾਸ ਸਮਾਲਟ

1 answers:
PHP ਨਾਲ ਵੱਡੀ ਫਾਈਲਾਂ ਕਿਵੇਂ ਪੜ੍ਹਨੀਆਂ ਹਨ (ਤੁਹਾਡਾ ਸਰਵਰ ਮਾਰਨ ਤੋਂ ਬਿਨਾਂ)

ਸਿਮਟਲ ਅਕਸਰ ਨਹੀਂ ਹੁੰਦਾ ਕਿ, ਅਸੀਂ PHP ਡੀਵੈਲਪਰ ਦੇ ਤੌਰ ਤੇ, ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਬਾਰੇ ਚਿੰਤਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ. PHP ਇੰਜਣ ਸਾਡੇ ਦੁਆਰਾ ਸਫਾਈ ਕਰਨ ਦੀ ਇੱਕ ਸ਼ਾਨਦਾਰ ਨੌਕਰੀ ਕਰਦਾ ਹੈ, ਅਤੇ ਥੋੜੇ ਸਮੇਂ ਦੇ ਚੱਲਣ ਦੇ ਪ੍ਰਸਾਰਣਾਂ ਦੇ ਵੈਬ ਸਰਵਰ ਮਾਡਲ ਦਾ ਮਤਲਬ ਹੈ ਕਿ sloppiest ਕੋਡ ਦਾ ਕੋਈ ਲੰਮੇ ਸਮੇਂ ਤਕ ਪ੍ਰਭਾਵ ਨਹੀਂ ਹੁੰਦਾ.

ਦੁਰਲੱਭ ਸਮੇਂ ਜਦੋਂ ਸਾਨੂੰ ਇਸ ਅਰਾਮ ਦੀ ਹੱਦ ਤੋਂ ਬਾਹਰ ਕਦਮ ਚੁੱਕਣ ਦੀ ਜ਼ਰੂਰਤ ਪੈਂਦੀ ਹੈ - ਜਿਵੇਂ ਕਿ ਜਦੋਂ ਅਸੀਂ ਵੱਡੇ ਪ੍ਰੋਜੈਕਟ ਲਈ ਵੱਡੇ ਪ੍ਰੋਜੈਕਟ ਦੀ ਅਸੀਂ ਬਣਾ ਸਕਦੇ ਹਾਂ, ਜਾਂ ਜਦੋਂ ਸਾਨੂੰ ਵੱਡੇ ਫਾਈਲਾਂ ਨੂੰ ਬਰਾਬਰ ਦਾ ਛੋਟਾ ਸਰਵਰ

How to Read Big Files with PHP (Without Killing Your Server)How to Read Big Files with PHP (Without Killing Your Server)Related Topics:
DrupalDevelopment Semalt

ਬਾਅਦ ਦੀ ਸਮੱਸਿਆ ਨੂੰ ਮਿਟਾਓ ਅਸੀਂ ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿਚ ਦੇਖਾਂਗੇ.

ਇਸ ਟਿਊਟੋਰਿਅਲ ਦਾ ਕੋਡ ਗਿਟ ਹਾਬ ਤੇ ਪਾਇਆ ਜਾ ਸਕਦਾ ਹੈ - sigelei v3 manual.

ਸਫਲਤਾ ਦਾ ਪਰਖਣ

ਇਹ ਨਿਸ਼ਚਿਤ ਕਰਨ ਦਾ ਇਕੋ ਇਕ ਤਰੀਕਾ ਹੈ ਕਿ ਅਸੀਂ ਆਪਣੇ ਕੋਡ ਵਿੱਚ ਕੋਈ ਸੁਧਾਰ ਕਰ ਰਹੇ ਹਾਂ ਇੱਕ ਬੁਰੀ ਸਥਿਤੀ ਨੂੰ ਮਾਪਣਾ ਅਤੇ ਫਿਰ ਉਸ ਮਾਪ ਦੀ ਤੁਲਨਾ ਇਕ ਹੋਰ ਨਾਲ ਕਰਨ ਤੋਂ ਬਾਅਦ ਜਦੋਂ ਅਸੀਂ ਆਪਣੇ ਫਿਕਸ ਨੂੰ ਲਾਗੂ ਕਰਦੇ ਹਾਂ. ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿਚ, ਜਦੋਂ ਤੱਕ ਸਾਨੂੰ ਇਹ ਨਹੀਂ ਪਤਾ ਹੁੰਦਾ ਕਿ "ਹੱਲ" ਸਾਡੀ ਮਦਦ ਕਿਵੇਂ ਕਰਦਾ ਹੈ (ਜੇ ਸਭ ਕੁਝ ਹੈ), ਅਸੀਂ ਇਹ ਨਹੀਂ ਜਾਣ ਸਕਦੇ ਕਿ ਇਹ ਅਸਲ ਵਿਚ ਕੋਈ ਹੱਲ ਹੈ ਜਾਂ ਨਹੀਂ.

ਦੋ ਮੈਟ੍ਰਿਕਸ ਹਨ ਜੋ ਅਸੀਂ ਦੇਖ ਸਕਦੇ ਹਾਂ ਪਹਿਲੀ CPU ਵਰਤੋਂ ਹੈ ਕਿਸ ਪ੍ਰਕਿਰਿਆ 'ਤੇ ਅਸੀਂ ਕੰਮ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ ਇਹ ਕਿੰਨੀ ਤੇਜ਼ੀ ਨਾਲ ਜਾਂ ਹੌਲੀ ਹੈ? ਦੂਜਾ ਮੈਮੋਰੀ ਵਰਤੋਂ ਹੈ ਸਕ੍ਰਿਪਟ ਨੂੰ ਚਲਾਉਣ ਲਈ ਕਿੰਨੀ ਮੈਮੋਰੀ ਲਗਦੀ ਹੈ? ਸਿਮਟਟ ਅਕਸਰ ਉਲਟ ਅਨੁਪਾਤਕ ਹੁੰਦੇ ਹਨ - ਭਾਵ ਕਿ ਅਸੀਂ CPU ਉਪਯੋਗਤਾ ਦੀ ਲਾਗਤ ਤੇ ਮੈਮੋਰੀ ਵਰਤੋਂ ਬੰਦ ਕਰ ਸਕਦੇ ਹਾਂ, ਅਤੇ ਉਲਟ.

ਅਸਿੰਕਰੋਨਸ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਮਾਡਲ (ਜਿਵੇਂ ਮਲਟੀ-ਪ੍ਰਕਿਰਿਆ ਜਾਂ ਮਲਟੀ-ਥ੍ਰੈਡਡ PHP ਐਪਲੀਕੇਸ਼ਨਸ) ਦੇ ਨਾਲ, CPU ਅਤੇ ਮੈਮੋਰੀ ਵਰਤੋਂ ਦੋਵੇਂ ਅਹਿਮ ਵਿਚਾਰ ਹਨ. ਰਵਾਇਤੀ PHP ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ, ਇਹ ਆਮ ਤੌਰ ਤੇ ਇੱਕ ਸਮੱਸਿਆ ਬਣ ਜਾਂਦੇ ਹਨ ਜਦੋਂ ਕੋਈ ਇੱਕ ਸਰਵਰ ਦੀਆਂ ਸੀਮਾਵਾਂ ਤੱਕ ਪਹੁੰਚਦਾ ਹੈ.

PHP ਦੇ ਅੰਦਰ CPU ਉਪਯੋਗਤਾ ਨੂੰ ਮਾਪਣਾ ਅਵੱਸ਼ਕ ਹੈ. ਜੇ ਇਹ ਉਹ ਖੇਤਰ ਹੈ ਜਿਸਤੇ ਤੁਸੀਂ ਧਿਆਨ ਕੇਂਦਰਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਉਬਤੂੰ ਜਾਂ ਮੈਕੌਸ ਤੇ ਕੁਝ ਸਿਖਰ ਦੀ ਤਰ੍ਹਾਂ ਵਰਤੋ. ਵਿੰਡੋਜ਼ ਲਈ, ਲੀਨਕਸ ਉਪ-ਸਿਸਟਮ ਦੀ ਵਰਤੋਂ ਕਰਨ 'ਤੇ ਵਿਚਾਰ ਕਰੋ, ਤਾਂ ਕਿ ਤੁਸੀਂ ਉਬਤੂੰ ਵਿੱਚ ਚੋਟੀ ਦੇ ਇਸਤੇਮਾਲ ਕਰ ਸਕਦੇ ਹੋ.

ਇਸ ਟਿਯੂਟੋਰਿਅਲ ਦੇ ਉਦੇਸ਼ਾਂ ਲਈ, ਅਸੀਂ ਮੈਮੋਰੀ ਵਰਤੋਂ ਨੂੰ ਮਾਪਣ ਜਾ ਰਹੇ ਹਾਂ. "ਪ੍ਰੰਪਰਾਗਤ" ਸਕ੍ਰਿਪਟਾਂ ਵਿੱਚ ਮਿਮਾਲ ਨੂੰ ਕਿੰਨੀ ਮੈਮੋਰੀ ਵਰਤੀ ਜਾਂਦੀ ਹੈ ਇਸਦੇ ਬਾਰੇ ਮੀਮਟ ਰੂਪ. ਮਿਮਾਲਾ ਨੇ ਦੋ ਅਨੁਕੂਲਤਾ ਦੀਆਂ ਰਣਨੀਤੀਆਂ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਵੀ ਮਾਪਿਆ ਹੈ. ਅੰਤ ਵਿੱਚ, ਮੈਂ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ ਤੁਸੀਂ ਇੱਕ ਪੜ੍ਹੇ-ਲਿਖੇ ਵਿਕਲਪ ਬਣਾਉਣ ਦੇ ਯੋਗ ਹੋਵੋ.

ਉਹ ਤਰੀਕਿਆਂ ਨੂੰ ਦੇਖਣ ਲਈ ਅਸੀਂ ਕਿੰਨੀ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ ਇਹ ਹਨ:

     // formatBytes php ਤੋਂ ਲਿਆ ਗਿਆ ਹੈ ਸ਼ੁੱਧ ਦਸਤਾਵੇਜ਼memory_get_peak_usage   ;ਫੰਕਸ਼ਨ ਫਾਰਮੈਟਬਾਈਟਸ ($ ਬਾਈਟ, $ ਸ਼ੁੱਧਤਾ = 2) {$ units = ਐਰੇ ("b", "kb", "mb", "gb", "tb");$ ਬਾਈਟ = ਅਧਿਕਤਮ ($ ਬਾਈਟ, 0);$ pow = floor (($ ਬਾਈਟ? ਲਾੱਗ ($ ਬਾਈਟ): 0) / ਲਾਗ (1024));$ ਪਾਓ = ਮਿੰਟ ($ ਪਾਓ, ਗਿਣਤੀ ($ ਯੂਨਿਟ) - 1);$ ਬਾਈਟ / = (1 << (10 * $ ਪਾਓ));ਵਾਪਸ ਵਾਪਸੀ ($ ਬਾਈਟ, $ ਸਹੀ). "". $ ਯੂਨਿਟ [$ pow];}    

ਮਿਮਾਲਟ ਸਾਡੇ ਫਾਰਮਾਂ ਦੇ ਅੰਤ ਤੇ ਇਹਨਾਂ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਅਸੀਂ ਦੇਖ ਸਕਦੇ ਹਾਂ ਕਿ ਕਿਸ ਸਕਰਿਪਟ ਨੂੰ ਇੱਕ ਸਮੇਂ ਤੇ ਜ਼ਿਆਦਾ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ.

ਸਾਡੇ ਵਿਕਲਪ ਕੀ ਹਨ?

ਸਿਮਟਟ ਕਈ ਤਰੀਕੇ ਹਨ ਜੋ ਅਸੀਂ ਫਾਈਲਾਂ ਨੂੰ ਪ੍ਰਭਾਵੀ ਤਰੀਕੇ ਨਾਲ ਪੜ੍ਹ ਸਕਦੇ ਹਾਂ. ਪਰ ਦੋ ਸੰਭਾਵਿਤ ਹਾਲਾਤ ਵੀ ਹਨ ਜਿਨ੍ਹਾਂ ਵਿਚ ਅਸੀਂ ਇਨ੍ਹਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ. ਅਸੀਂ ਇਕੋ ਸਮੇਂ ਸਾਰੇ ਡਾਟਾ ਪੜ੍ਹ ਅਤੇ ਪ੍ਰਕਿਰਿਆ ਕਰਨਾ ਚਾਹ ਸਕਦੇ ਹਾਂ, ਪ੍ਰੋਸੈਸਡ ਡਾਟਾ ਨੂੰ ਆਉਟਪੁੱਟ ਕਰ ਸਕਦੇ ਹਾਂ ਜਾਂ ਜੋ ਅਸੀਂ ਪੜ੍ਹਦੇ ਹਾਂ ਉਸ ਦੇ ਅਧਾਰ ਤੇ ਹੋਰ ਕਿਰਿਆਵਾਂ ਕਰ ਰਹੇ ਹਾਂ. ਅਸੀਂ ਕਦੇ ਵੀ ਅਸਲ ਵਿੱਚ ਡਾਟਾ ਤੱਕ ਪਹੁੰਚ ਦੀ ਲੋੜ ਤੋਂ ਬਿਨਾਂ ਡਾਟਾ ਦੀ ਇੱਕ ਧਾਰਾ ਬਦਲਣਾ ਚਾਹ ਸਕਦੇ ਹਾਂ.

ਆਓ ਪਹਿਲਾਂ ਦੀ ਸਥਿਤੀ ਲਈ ਸੋਚੀਏ, ਕਿ ਅਸੀਂ ਹਰ 10,000 ਲਾਈਨਾਂ ਦੀ ਇਕ ਫਾਇਲ ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਅਲੱਗ ਕਤਾਰਬੱਧ ਪ੍ਰਕਿਰਿਆ ਦੀਆਂ ਨੌਕਰੀਆਂ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹਾਂ. ਮਿਮਾਲਕ ਨੂੰ ਘੱਟੋ ਘੱਟ 10,000 ਲਾਈਨਾਂ ਮੈਮੋਰੀ ਵਿਚ ਰੱਖਣ ਦੀ ਲੋੜ ਹੈ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਕਤਾਰਬੱਧ ਨੌਕਰੀ ਮੈਨੇਜਰ (ਜੋ ਵੀ ਹੋ ਸਕਦਾ ਹੈ) ਦੇ ਨਾਲ ਪਾਸ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ.

ਦੂਜੀ ਦ੍ਰਿਸ਼ਟੀ ਦੇ ਲਈ, ਮੰਨ ਲੈਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਅਸੀਂ ਖਾਸ ਤੌਰ ਤੇ ਵੱਡੀ API ਜਵਾਬ ਦੀ ਸਮਗਰੀ ਨੂੰ ਸੰਕੁਚਿਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ. ਸਾਨੂੰ ਇਸ ਦੀ ਕੋਈ ਪਰਵਾਹ ਨਹੀਂ ਕਿ ਇਹ ਕੀ ਕਹਿੰਦੀ ਹੈ, ਪਰ ਸਾਨੂੰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ ਕਿ ਇਸ ਦਾ ਕੰਪਰੈੱਸਡ ਰੂਪ ਵਿਚ ਬੈਕਅੱਪ ਕੀਤਾ ਗਿਆ ਹੈ. ਪਹਿਲਾਂ, ਸਾਨੂੰ ਇਹ ਜਾਣਨ ਦੀ ਲੋੜ ਹੈ ਕਿ ਡੇਟਾ ਕੀ ਹੈ ਦੂਜੀ ਵਿੱਚ, ਅਸੀਂ ਧਿਆਨ ਨਹੀਂ ਦਿੰਦੇ ਕਿ ਡੇਟਾ ਕੀ ਹੈ ਸਿਮਟਲ ਇਹ ਵਿਕਲਪਾਂ ਦਾ ਪਤਾ ਲਾਓ .

ਫਾਈਲਾਂ ਨੂੰ ਪੜ੍ਹਨਾ, ਲਾਇਨ ਕੇ ਲਾਈਨ

ਫਾਈਲਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਬਹੁਤ ਸਾਰੇ ਫੰਕਸ਼ਨ ਹਨ. ਮਿਠਾਈਆਂ ਕੁਝ ਨੂੰ ਇੱਕ ਨਿਰਬਲ ਫਾਈਲ ਰੀਡਰ ਵਿੱਚ ਜੋੜਦਾ ਹੈ:

     // ਮੈਮੋਰੀ ਤੋਂ phpਫੰਕਸ਼ਨ ਫਾਰਮੈਟਬਾਈਟਸ ($ ਬਾਈਟ, $ ਸ਼ੁੱਧਤਾ = 2) {$ units = ਐਰੇ ("b", "kb", "mb", "gb", "tb");$ ਬਾਈਟ = ਅਧਿਕਤਮ ($ ਬਾਈਟ, 0);$ pow = floor (($ ਬਾਈਟ? ਲਾੱਗ ($ ਬਾਈਟ): 0) / ਲਾਗ (1024));$ ਪਾਓ = ਮਿੰਟ ($ ਪਾਓ, ਗਿਣਤੀ ($ ਯੂਨਿਟ) - 1);$ ਬਾਈਟ / = (1 << (10 * $ ਪਾਓ));ਵਾਪਸ ਵਾਪਸੀ ($ ਬਾਈਟ, $ ਸਹੀ). "". $ ਯੂਨਿਟ [$ pow];}ਪ੍ਰਿੰਟ ਫਾਰਮੈਟਬਾਈਟਸ (ਮੈਮਰੀ _ਗ_ਪੀਕ_ਯੂਜ਼ਜ   );    
     // ਨੂੰ ਪੜ੍ਹਨ-ਫਾਈਲਾਂ-ਲਾਈਨ-ਬਾਈ-ਲਾਈਨ-1. phpਫੰਕਸ਼ਨ ਰੀਡਹਫੇਫਿਲ ($ ਮਾਰਗ) {$ lines = [];$ handle = fopen ($ ਪਾਥ, "r");ਜਦਕਿ (! ਫੀਫ ($ ਹੈਂਡਲ)) {$ lines [] = ਟ੍ਰਿਮ (fgets ($ ਹੈਂਡਲ));}fclose ($ ਹੈਂਡਲ);ਵਾਪਸੀ ਦੀਆਂ ਲਾਈਨਾਂ;}readTheFile ("ਸ਼ੇਕਸਪੀਅਰ. txt");"ਮੈਮੋਰੀ. php" ਦੀ ਲੋੜ ਹੈ;    

ਅਸੀਂ ਇੱਕ ਟੈਕਸਟ ਫਾਈਲ ਪੜ੍ਹ ਰਹੇ ਹਾਂ ਜਿਸ ਵਿੱਚ ਸ਼ੇਕਸਪੀਅਰ ਦੀਆਂ ਸਾਰੀਆਂ ਰਚਨਾਵਾਂ ਹਨ. ਟੈਕਸਟ ਫਾਇਲ ਲਗਭਗ 5. 5 ਮੈਬਾ ਹੈ, ਅਤੇ ਪੀਕ ਮੈਮੋਰੀ ਵਰਤੋਂ 12. 8 ਐਮ ਬੀ ਹੈ. ਹੁਣ, ਹਰ ਸਤਰ ਨੂੰ ਪੜ੍ਹਨ ਲਈ ਇੱਕ ਜਨਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰੀਏ:

     // ਰੀਡਿੰਗ-ਫਾਈਲਾਂ-ਲਾਈਨ-ਬਾਈ-ਲਾਈਨ -2. phpਫੰਕਸ਼ਨ ਰੀਡਹਫੇਫਿਲ ($ ਮਾਰਗ) {$ handle = fopen ($ ਪਾਥ, "r");ਜਦਕਿ (! ਫੀਫ ($ ਹੈਂਡਲ)) {ਪੈਦਾਵਾਰ ਟ੍ਰਿਮ (fgets ($ ਹੈਂਡਲ));}fclose ($ ਹੈਂਡਲ);}readTheFile ("ਸ਼ੇਕਸਪੀਅਰ. txt");"ਮੈਮੋਰੀ. php" ਦੀ ਲੋੜ ਹੈ;    

ਟੈਕਸਟ ਫਾਇਲ ਇਕੋ ਅਕਾਰ ਹੈ, ਪਰ ਪੀਕ ਮੈਮੋਰੀ ਵਰਤੋਂ 393 ਕੇ.ਬੀ. ਹੈ. ਇਸਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਹੈ ਕਿ ਜਦੋਂ ਤੱਕ ਅਸੀਂ ਪੜ੍ਹ ਰਹੇ ਹਾਂ ਉਸ ਨਾਲ ਕੁਝ ਨਹੀਂ ਕਰਦੇ. ਸ਼ਾਇਦ ਜਦੋਂ ਅਸੀਂ ਦਸਤਾਵੇਜ਼ ਨੂੰ ਦੋ ਖਾਲੀ ਲਾਈਨਾਂ ਦੇਖਦੇ ਹਾਂ ਤਾਂ ਅਸੀਂ ਦਸਤਾਵੇਜ਼ ਨੂੰ ਵੰਡ ਕੇ ਵੰਡ ਸਕਦੇ ਹਾਂ. ਇਸ ਤਰ੍ਹਾਂ ਕੁਝ:

     // ਰੀਡਿੰਗ-ਫਾਈਲਾਂ-ਲਾਈਨ-ਬਾਈ-ਲਾਈਨ -3. php$ iterator = readTheFile ("ਸ਼ੇਕਸਪੀਅਰ. txt");$ ਬਫਰ = "";ਫੋਰਚ ($ ਇਟ੍ਰੇਏਟਰ $ ਇਨਟਰਨਰੇਸ਼ਨ) {preg_match ("/ \ n {3} /", $ ਬਫਰ, $ ਮੈਚ);ਜੇ (ਗਿਣਤੀ ($ ਮੇਲ)) {ਛਾਪੋ ". ";$ ਬਫਰ = "";} else {$ ਬਫਰ. = $ ਦੁਹਰਾਈ. PHP_EOL;}}"ਮੈਮੋਰੀ. php" ਦੀ ਲੋੜ ਹੈ;    

ਕੋਈ ਅੰਦਾਜ਼ਾ ਹੈ ਕਿ ਅਸੀਂ ਹੁਣ ਕਿੰਨੀ ਮੈਮੋਰੀ ਵਰਤ ਰਹੇ ਹਾਂ? ਕੀ ਤੁਸੀਂ ਇਹ ਜਾਣ ਕੇ ਹੈਰਾਨ ਹੋਵੋਗੇ ਕਿ ਭਾਵੇਂ ਅਸੀਂ ਟੈਕਸਟ ਦਸਤਾਵੇਜ਼ ਨੂੰ 1,216 ਚੋਕਾਂ ਵਿਚ ਵੰਡਦੇ ਹਾਂ, ਤਾਂ ਵੀ ਅਸੀਂ ਅਜੇ ਵੀ 459 ਕੇ.ਬੀ. ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ? ਜਨਰੇਟਰਾਂ ਦੀ ਪ੍ਰਕ੍ਰਿਤੀ ਦੇ ਮੱਦੇਨਜ਼ਰ, ਸਭ ਤੋਂ ਵੱਧ ਮੈਮੋਰੀ ਜੋ ਅਸੀਂ ਵਰਤੀਏ, ਉਹ ਹੈ ਜੋ ਸਾਨੂੰ ਕਿਸੇ ਦੁਹਰਾਉਣ ਦੇ ਸਭ ਤੋਂ ਵੱਡੇ ਪਾਠ ਦੇ ਭਾਗ ਨੂੰ ਸੰਭਾਲਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ. ਇਸ ਕੇਸ ਵਿੱਚ, ਸਭ ਤੋਂ ਵੱਡਾ ਖੰਡ 101,985 ਅੱਖਰ ਹਨ.

ਮੈਂ ਪਹਿਲਾਂ ਹੀ ਜਨਰੇਟਰਾਂ ਅਤੇ ਨਿਕਿਤਾ ਪੋਪੋ ਦੇ ਸੇਮਟ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਵਧਾਉਣ ਬਾਰੇ ਲਿਖਿਆ ਹੈ, ਇਸ ਲਈ ਇਸ ਨੂੰ ਚੈੱਕ ਕਰੋ ਕਿ ਜੇ ਤੁਸੀਂ ਹੋਰ ਵੇਖਣਾ ਚਾਹੁੰਦੇ ਹੋ!

ਸੈਮਲਾਟ ਕੋਲ ਹੋਰ ਵਰਤੋਂ ਹਨ, ਪਰੰਤੂ ਇਹ ਵੱਡੀ ਫਾਈਲਾਂ ਪੜ੍ਹਨ ਵਿਚ ਸਫ਼ਲ ਹੋਣ ਲਈ ਚੰਗਾ ਪ੍ਰਦਰਸ਼ਨ ਹੈ. ਜੇ ਸਾਨੂੰ ਡਾਟਾ ਤੇ ਕੰਮ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਜੈਨਰੇਟਰ ਸ਼ਾਇਦ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕਾ ਹੈ.

ਫਾਈਲਾਂ ਵਿਚਕਾਰ ਪਾਈਪਿੰਗ

ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਜਿੱਥੇ ਸਾਨੂੰ ਡੇਟਾ ਤੇ ਕੰਮ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਅਸੀਂ ਫਾਈਲ ਡਾਟਾ ਨੂੰ ਇੱਕ ਫਾਈਲ ਤੋਂ ਦੂਜੀ ਵਿੱਚ ਪਾਸ ਕਰ ਸਕਦੇ ਹਾਂ. ਇਸਨੂੰ ਆਮ ਤੌਰ ਤੇ 11 ਪਾਈਪਿੰਗ ਕਿਹਾ ਜਾਂਦਾ ਹੈ (ਸੰਭਵ ਤੌਰ 'ਤੇ ਕਿਉਂਕਿ ਅਸੀਂ ਇਹ ਨਹੀਂ ਦੇਖ ਸਕਦੇ ਕਿ ਪਾਈਪ ਦੇ ਅੰਦਰ ਕੀ ਹੈ ਅਤੇ ਹਰੇਕ ਪਾਸੇ ਇਸਨੂੰ ਛੱਡਣਾ ਹੈ .ਜਿੰਨਾ ਚਿਰ ਇਹ ਅਪਾਰਦਰਸ਼ੀ ਹੈ!). ਅਸੀਂ ਸਟ੍ਰੀਮ ਦੇ ਤਰੀਕਿਆਂ ਦਾ ਇਸਤੇਮਾਲ ਕਰਕੇ ਇਸਨੂੰ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ. ਆਓ ਪਹਿਲਾਂ ਇੱਕ ਸਕਰਿਪਟ ਨੂੰ ਇੱਕ ਫਾਈਲ ਤੋਂ ਦੂਜੀ ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਲਈ ਲਿਖੀਏ, ਤਾਂ ਕਿ ਅਸੀਂ ਮੈਮੋਰੀ ਵਰਤੋਂ ਮਾਪ ਸਕੀਏ:

     // ਪਾਈਪਿੰਗ-ਫਾਈਲਾਂ-1 ਤੋਂ phpfile_put_contents ("ਪਾਈਪਿੰਗ-ਫਾਈਲਾਂ- 1. txt", file_get_contents ("ਸ਼ੇਕਸਪੀਅਰ. txt"));"ਮੈਮੋਰੀ. php" ਦੀ ਲੋੜ ਹੈ;    

ਹੈਰਾਨੀ ਵਾਲੀ ਗੱਲ ਇਹ ਹੈ ਕਿ ਇਹ ਸਕਰਿਪਟ ਟੈਕਸਟ ਦੀ ਬਜਾਏ ਚਲਾਉਣ ਲਈ ਥੋੜ੍ਹੀ ਜਿਹੀ ਮੈਮੋਰੀ ਵਰਤਦੀ ਹੈ. ਮੀਮੋਲ ਕਿਉਂਕਿ ਇਸ ਨੂੰ ਮੈਮੋਰੀ ਵਿੱਚ ਫਾਈਲ ਸਮੱਗਰੀ ਨੂੰ ਪੜ੍ਹਨਾ (ਅਤੇ ਰੱਖਣਾ) ਉਦੋਂ ਤੱਕ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜਦੋਂ ਤਕ ਇਹ ਨਵੀਂ ਫਾਇਲ ਨੂੰ ਨਹੀਂ ਲਿਖਿਆ ਜਾਂਦਾ. ਛੋਟੇ ਫਾਈਲਾਂ ਲਈ, ਇਹ ਠੀਕ ਹੋ ਸਕਦਾ ਹੈ. ਜਦੋਂ ਅਸੀਂ ਵੱਡੀ ਫਾਈਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਬਹੁਤ ਕੁਝ .

ਸੈਮਟ ਸਟਰੀਮਿੰਗ (ਜਾਂ ਪਾਈਪਿੰਗ) ਇੱਕ ਫਾਈਲ ਤੋਂ ਦੂਸਰੇ ਵਿਚ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ:

     // ਪਾਈਪਿੰਗ-ਫਾਈਲਾਂ -2 ਤੋਂ. txt "," r ");$ handle2 = fopen ("ਪਾਈਪਿੰਗ-ਫਾਈਲਾਂ -2. txt", "w");stream_copy_to_stream ($ ਹੈਂਡਲ 1, $ ਹੈਂਡਲ 2);fclose ($ handle1);fclose ($ handle2);"ਮੈਮੋਰੀ. php" ਦੀ ਲੋੜ ਹੈ;    

ਇਹ ਕੋਡ ਥੋੜਾ ਅਜੀਬ ਹੈ. ਅਸੀਂ ਦੋਵੇਂ ਫਾਈਲਾਂ ਤੇ ਹੈਂਡਲਜ਼ ਖੋਲ੍ਹਦੇ ਹਾਂ, ਪਹਿਲਾਂ ਰੀਡਡ ਮੋਡ ਅਤੇ ਦੂਸਰਾ ਰਾਈਟਮ ਮੋਡ. ਫਿਰ ਅਸੀਂ ਪਹਿਲੇ ਤੋਂ ਦੂਜੀ ਵਿੱਚ ਕਾਪੀ ਕਰਦੇ ਹਾਂ ਅਸੀਂ ਫੇਰ ਦੋਵਾਂ ਫਾਈਲਾਂ ਨੂੰ ਬੰਦ ਕਰਕੇ ਖ਼ਤਮ ਕਰਦੇ ਹਾਂ. ਇਹ ਤੁਹਾਨੂੰ ਹੈਰਾਨ ਕਰਨ ਲਈ ਹੈਰਾਨੀ ਹੁੰਦੀ ਹੈ ਕਿ ਵਰਤੀ ਜਾਂਦੀ ਮੈਮੋਰੀ 393 ਕਿਬਾ ਹੈ.

ਇਹ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ ਕੀ ਇਹ ਨਹੀਂ ਹੈ ਕਿ ਹਰੇਕ ਲਾਈਨ ਨੂੰ ਪੜ੍ਹਦੇ ਸਮੇਂ ਕੀ ਜੈਨਰੇਟਰ ਕੋਡ ਸਟੋਰ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ? ਇਹ ਇਸ ਕਰਕੇ ਹੈ ਕਿ ਦੂਜੀ ਦਲੀਲ fgets ਨਿਸ਼ਚਿਤ ਕਰਦੀ ਹੈ ਕਿ ਹਰੇਕ ਲਾਈਨ ਦੇ ਕਿੰਨੇ ਬਾਈਟਾਂ ਨੂੰ ਪੜ੍ਹਨ ਲਈ (ਅਤੇ ਡਿਫਾਲਟ -1 ਜਾਂ ਜਦੋਂ ਤਕ ਇਹ ਨਵੀਂ ਲਾਈਨ ਨਹੀਂ ਪਹੁੰਚਦਾ).

ਤੀਜੀ ਦਲੀਲ stream_copy_to_stream ਬਿਲਕੁਲ ਉਸੇ ਤਰ੍ਹਾ ਦੀ ਪੈਰਾਮੀਟਰ ਹੈ (ਬਿਲਕੁਲ ਉਸੇ ਡਿਫਾਲਟ ਨਾਲ). stream_copy_to_stream ਇੱਕ ਸਟ੍ਰੀਮ ਤੋਂ ਪੜ੍ਹ ਰਿਹਾ ਹੈ, ਇੱਕ ਸਮੇਂ ਇੱਕ ਲਾਈਨ, ਅਤੇ ਦੂਜੀ ਸਟ੍ਰੀਮ ਵਿੱਚ ਲਿਖਣਾ. ਇਹ ਉਸ ਹਿੱਸੇ ਨੂੰ ਛੂੰਹਦਾ ਹੈ ਜਿੱਥੇ ਜਨਰੇਟਰ ਇੱਕ ਮੁੱਲ ਦਿੰਦੇ ਹਨ, ਕਿਉਂਕਿ ਸਾਨੂੰ ਉਸ ਵੈਲਯੂ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ.

ਇਸ ਪਾਠ ਦੀ ਪਾਈਪਿੰਗ ਸਾਡੇ ਲਈ ਫਾਇਦੇਮੰਦ ਨਹੀਂ ਹੈ, ਇਸ ਲਈ ਆਉ ਦੂਜੀ ਉਦਾਹਰਨਾਂ ਬਾਰੇ ਸੋਚੀਏ ਜੋ ਸ਼ਾਇਦ ਹੋ ਸਕਦੀਆਂ ਹਨ. ਮਿਡਲ ਅਸੀਂ ਆਪਣੇ CDN ਤੋਂ ਇੱਕ ਚਿੱਤਰ ਨੂੰ ਆਊਟਪੁੱਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਸੀ, ਜਿਵੇਂ ਕਿ ਰੀਡਾਇਰੈਕਟਿਡ ਐਪਲੀਕੇਸ਼ਨ ਰੂਟ. ਅਸੀਂ ਇਸ ਨੂੰ ਹੇਠ ਲਿਖੀਆ ਕੋਡ ਨਾਲ ਦਰਸਾ ਸਕਦੇ ਹਾਂ:

     // ਪਾਈਪਿੰਗ-ਫਾਈਲਾਂ -3 ਤੋਂ phpfile_put_contents ("ਪਾਈਪਿੰਗ-ਫਾਈਲਾਂ -3. jpeg", file_get_contents ("https: // github. com / assertchris / uploads / raw / ਮਾਸਟਰ / ਰਿਕ. jpg"));// ਜਾਂ ਇਸ ਨੂੰ ਸਿੱਧੇ ਸਟਡઆઉટ ਤੇ ਲਿਖੋ, ਜੇ ਸਾਨੂੰ ਮੈਮੋਰੀ ਜਾਣਕਾਰੀ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ"ਮੈਮੋਰੀ. php" ਦੀ ਲੋੜ ਹੈ;    

ਕਲਪਨਾ ਕਰੋ ਕਿ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਰੂਟ ਸਾਨੂੰ ਇਸ ਕੋਡ ਤੇ ਲੈ ਆਇਆ ਹੈ. ਪਰ ਲੋਕਲ ਫਾਇਲ ਸਿਸਟਮ ਤੋਂ ਇੱਕ ਫਾਇਲ ਦੀ ਬਜਾਏ, ਅਸੀਂ ਇੱਕ ਸੀ ਡੀ ਐਨ ਤੋਂ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ. ਅਸੀਂ file_get_contents ਨੂੰ ਹੋਰ ਸ਼ਾਨਦਾਰ ਚੀਜ਼ (ਜਿਵੇਂ ਗਜਲੇ) ਦੇ ਬਦਲ ਦੇ ਤੌਰ ਤੇ ਬਦਲ ਸਕਦੇ ਹਾਂ, ਪਰ ਹੁੱਡ ਦੇ ਅਧੀਨ ਇਹ ਬਹੁਤ ਕੁਝ ਹੈ.

ਮੈਮੋਰੀ ਵਰਤੋਂ (ਇਸ ਚਿੱਤਰ ਲਈ) ਆਲੇ-ਦੁਆਲੇ 581 ਕੇ.ਬੀ. ਹੈ. ਹੁਣ, ਅਸੀਂ ਇਸ ਦੀ ਬਜਾਏ ਇਸ ਨੂੰ ਕਿਵੇਂ ਸਟਰੀਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਾਂਗੇ?

     // ਪਾਈਪਿੰਗ-ਫਾਈਲਾਂ -4 ਤੋਂ php$ handle1 = ਫੋਪੈਨ ("https: // github. com / assertchris / uploads / raw / ਮਾਸਟਰ / ਰਿਕ. jpg", "r");$ ਹੈਂਡਲ 2 = ਫੋਪੈਨ ("ਪਾਈਪਿੰਗ-ਫਾਈਲਾਂ -4. jpeg", "w");// ਜਾਂ ਇਸ ਨੂੰ ਸਿੱਧੇ ਸਟਡઆઉટ ਤੇ ਲਿਖੋ, ਜੇ ਸਾਨੂੰ ਮੈਮੋਰੀ ਜਾਣਕਾਰੀ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈstream_copy_to_stream ($ ਹੈਂਡਲ 1, $ ਹੈਂਡਲ 2);fclose ($ handle1);fclose ($ handle2);"ਮੈਮੋਰੀ. php" ਦੀ ਲੋੜ ਹੈ;    

ਮੈਮਰੀ ਦੀ ਵਰਤੋਂ ਥੋੜ੍ਹਾ ਘੱਟ ਹੈ ( 400 ਕੇ.ਬੀ. ), ਪਰ ਨਤੀਜਾ ਉਹੀ ਹੈ. ਜੇ ਸਾਨੂੰ ਮੈਮੋਰੀ ਜਾਣਕਾਰੀ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ, ਤਾਂ ਅਸੀਂ ਮਿਆਰੀ ਆਉਟਪੁੱਟ ਤੇ ਵੀ ਛਾਪ ਸਕਦੇ ਹਾਂ. ਵਾਸਤਵ ਵਿੱਚ, PHP ਇਸ ਤਰ੍ਹਾਂ ਕਰਨ ਦਾ ਇੱਕ ਸੌਖਾ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ:

     $ ਹੈਂਡਲ 1 = ਫੋਪੇਨ ("https: // github. com / assertchris / uploads / raw / ਮਾਸਟਰ / ਰਿਕ. jpg", "r");$ ਹੈਂਡਲ 2 = ਫੋਪੈਨ ("php: // stdout", "w");stream_copy_to_stream ($ ਹੈਂਡਲ 1, $ ਹੈਂਡਲ 2);fclose ($ handle1);fclose ($ handle2);// "ਮੈਮੋਰੀ. php" ਦੀ ਲੋੜ ਹੈ;    

ਹੋਰ ਸਟ੍ਰੀਮਸ

ਮਿਟੈਲਟ ਕੁਝ ਹੋਰ ਸਟਰੀਮ ਹਨ ਜੋ ਅਸੀਂ ਪਾਈਪ ਅਤੇ / ਜਾਂ ਲਿਖ ਸਕਦੇ ਹਾਂ ਅਤੇ / ਜਾਂ ਪੜ੍ਹ ਸਕਦੇ ਹਾਂ:

  • php: // ਸਟਡਿਨ (ਰੀਡ-ਓਨਲੀ)
  • php: // stderr (ਸਿਰਫ-ਲਿਖੋ, ਜਿਵੇਂ php: // stdout)
  • php: // ਇਨਪੁਟ (ਰੀਡ-ਓਨਲੀ) ਜੋ ਸਾਨੂੰ ਕੱਚਾ ਬੇਨਤੀ ਸੰਸਥਾ
  • ਤਕ ਪਹੁੰਚ ਦਿੰਦਾ ਹੈ.
  • php: // ਆਉਟਪੁਟ (ਸਿਰਫ-ਲਿਖੋ) ਜਿਸ ਨਾਲ ਸਾਨੂੰ ਆਊਟਪੁੱਟ ਬਫਰ
  • php: // ਮੈਮੋਰੀ ਅਤੇ php: // temp (ਰੀਡ-ਲਿਟਿਡ) ਉਹ ਥਾਂ ਹਨ ਜੋ ਅਸੀਂ ਅਸਥਾਈ ਤੌਰ ਤੇ ਡਾਟਾ ਸਟੋਰ ਕਰ ਸਕਦੇ ਹਾਂ. ਫਰਕ ਇਹ ਹੈ ਕਿ php: // temp ਇੱਕ ਵਾਰ ਫਾਈਲ ਸਿਸਟਮ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਸੰਭਾਲ ਕੇ ਰੱਖੇਗੀ, ਜਦੋਂ ਕਿ php: // ਮੈਮੋਰੀ ਮੈਮੋਰੀ ਵਿੱਚ ਸਾਂਭਣਾ ਜਾਰੀ ਰੱਖੇਗੀ .

ਫਿਲਟਰ

ਇਕ ਹੋਰ ਚਾਲ ਹੈ ਜਿਸਨੂੰ ਅਸੀਂ ਫਿਲਟਰਾਂ ਕਹਿੰਦੇ ਹਨ. ਉਹ ਇੱਕ ਕਿਸਮ ਦੇ ਵਿਚਕਾਰਲੇ ਕਦਮ ਹਨ, ਸਟ੍ਰੀਮ ਡੈਟਾ ਦੇ ਉੱਤੇ ਛੋਟੇ-ਛੋਟੇ ਨਿਯੰਤਰਣ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹੋਏ ਸਾਨੂੰ ਇਹ ਖੁਲਾਸਾ ਕਰਦੇ ਹਨ ਕਲਪਨਾ ਕਰੋ ਕਿ ਅਸੀਂ ਸ਼ੇਕਸਪੀਅਰ ਨੂੰ ਸੰਕੁਚਿਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ txt . php$ zip = ਨਵੇਂ ਜ਼ਿਪ ਆਰਖਿਵ ;$ filename = "ਫਿਲਟਰ -1. ਜ਼ਿਪ";$ zip-> ਖੁਲ੍ਹੋ ($ ਫਾਈਲ ਦਾ ਨਾਮ, ਜ਼ਿਪ ਅਚਾਰੀ :: ਬਣਾਓ);$ zip-> addFromString ("ਸ਼ੇਕਸਪੀਅਰ. txt", file_get_contents ("ਸ਼ੇਕਸਪੀਅਰ. txt"));$ zip-> ਬੰਦ ;"ਮੈਮੋਰੀ. php" ਦੀ ਲੋੜ ਹੈ;

ਇਹ ਕੋਡ ਦੀ ਇੱਕ ਸਾਫਟ ਬਿੱਟ ਹੈ, ਪਰ ਇਹ ਘੁਸਪੈਠ 10. 75MB ਤੇ ਹੈ. ਫਿਲਟਰਾਂ ਨਾਲ ਅਸੀਂ ਵਧੀਆ ਕਰ ਸਕਦੇ ਹਾਂ:

     // ਫਿਲਟਰ ਤੋਂ -2 php$ handle1 = ਫੋਪੈਨ ("php: // filter / zlib. deflate / source = ਸ਼ੇਕਸਪੀਅਰ. txt", "r");$ ਹੈਂਡਲ 2 = ਫੋਪੈਨ ("ਫਿਲਟਰ -2. ਘਾਟ", "ਵਾ");stream_copy_to_stream ($ ਹੈਂਡਲ 1, $ ਹੈਂਡਲ 2);fclose ($ handle1);fclose ($ handle2);"ਮੈਮੋਰੀ. php" ਦੀ ਲੋੜ ਹੈ;    

ਇੱਥੇ, ਅਸੀਂ php: // filter / zlib ਵੇਖ ਸਕਦੇ ਹਾਂ. ਡਿਫਾਲਟ ਫਿਲਟਰ, ਜੋ ਕਿਸੇ ਸਰੋਤ ਦੀ ਸਮਗਰੀ ਨੂੰ ਪੜ੍ਹਦਾ ਅਤੇ ਸੰਕੁਚਿਤ ਕਰਦਾ ਹੈ. ਅਸੀਂ ਫਿਰ ਇਸ ਕੰਪਰੈਸਡ ਡਾਟੇ ਨੂੰ ਇਕ ਹੋਰ ਫਾਈਲ ਵਿਚ ਪਾਈਪ ਕਰ ਸਕਦੇ ਹਾਂ. ਇਹ ਸਿਰਫ 896 ਕੇ.ਬੀ. ਵਰਤਦਾ ਹੈ.

ਮੈਨੂੰ ਪਤਾ ਹੈ ਕਿ ਇਹ ਇਕੋ ਫਾਰਮੈਟ ਨਹੀਂ ਹੈ, ਜਾਂ ਇਹ ਕਿ ਜ਼ਿਪ ਆਰਕਾਈਵ ਬਣਾਉਣ ਦੇ ਉਛਾਲ ਹਨ. ਤੁਹਾਨੂੰ ਹੈਰਾਨ ਹੋਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ: ਜੇ ਤੁਸੀਂ ਵੱਖਰੇ ਫਾਰਮੇਟ ਦੀ ਚੋਣ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ 12 ਵਾਰ ਮੈਮੋਰੀ ਬਚਾ ਸਕਦੇ ਹੋ, ਕੀ ਤੁਸੀਂ ਨਹੀਂ?

ਡੇਟਾ ਨੂੰ ਅਣਕੰਪਿਤ ਕਰਨ ਲਈ, ਅਸੀਂ deflated ਫਾਈਲ ਨੂੰ ਦੂਜੇ zlib ਫਿਲਟਰ ਰਾਹੀਂ ਵਾਪਸ ਚਲਾ ਸਕਦੇ ਹਾਂ:

     // ਫਿਲਟਰ ਤੋਂ -2 phpfile_get_contents ("php: // filter / zlib ਫ੍ਰੀੇਟ / ਸਰੋਸ = ਫਿਲਟਰ -2.);    

"PHP ਵਿੱਚ ਸਟ੍ਰੀਮਜ਼ ਨੂੰ ਸਮਝਣਾ" ਅਤੇ "PHP ਸਟ੍ਰੀਮਜ਼ ਸਾਮਲਟ ਦੀ ਵਰਤੋਂ" ਵਿੱਚ ਸਟ੍ਰੀਮਜ਼ ਨੂੰ ਵਿਆਪਕ ਤਰੀਕੇ ਨਾਲ ਕਵਰ ਕੀਤਾ ਗਿਆ ਹੈ. ਜੇ ਤੁਸੀਂ ਇੱਕ ਵੱਖਰੇ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਚੈੱਕ ਕਰੋ!

ਸਟ੍ਰੀਮਜ਼ ਨੂੰ ਕਸਟਮਾਈਜ ਕਰਨਾ

ਫੋਪੈਨ ਅਤੇ ਫਾਈਲ_ਗਟਿਸਟੀਟੈਂਟ ਕੋਲ ਆਪਣਾ ਡਿਫਾਲਟ ਵਿਕਲਪ ਹਨ, ਪਰ ਇਹ ਪੂਰੀ ਤਰਾਂ ਨਾਲ ਅਨੁਕੂਲ ਹਨ. ਇਹਨਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਇੱਕ ਨਵੇਂ ਸਟਰੀਟ ਪ੍ਰਸੰਗ ਨੂੰ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ:

     // ਬਣਾਉਣ-ਪ੍ਰਸੰਗ -1 ਤੋਂ. php$ data = join ("ਅਤੇ", ["ਟਵਿੱਟਰ = ਅਟੇਚਰਸ",]);$ headers = join ("\ r \ n", ["ਸਮੱਗਰੀ-ਕਿਸਮ: ਐਪਲੀਕੇਸ਼ਨ / x-www-form-urlencoded","ਸਮੱਗਰੀ-ਲੰਬਾਈ:". strlen ($ ਡਾਟਾ),]);$ options = ["http" => ["ਵਿਧੀ" => "ਪੋਸਟ","ਹੈਡਰ" => $ ਹੈਡਰ,"ਸਮੱਗਰੀ" => $ ਡਾਟਾ,],];$ context = stream_content_create ($ ਵਿਕਲਪ);$ handle = fopen ("https: // ਉਦਾਹਰਨ. / ਰਜਿਸਟਰ", "r", ਗਲਤ, $ ਸੰਦਰਭ);$ ਪ੍ਰਤੀਕਿਰਿਆ = ਸਟ੍ਰੀਮ_ਗਤਿ_contents ($ ਹੈਂਡਲ);fclose ($ ਹੈਂਡਲ);    

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਅਸੀਂ API ਨੂੰ POST ਬੇਨਤੀ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਹੇ ਹਾਂ. API ਅੰਤ ਬਿੰਦੂ ਸੁਰੱਖਿਅਤ ਹੈ, ਪਰ ਸਾਨੂੰ ਅਜੇ ਵੀ http ਸੰਦਰਭ ਪ੍ਰੌਪਰਟੀ (ਜਿਵੇਂ http ਅਤੇ https ) ਲਈ ਵਰਤਿਆ ਗਿਆ ਹੈ. ਅਸੀਂ ਕੁਝ ਸਿਰਲੇਖ ਸੈਟ ਕਰਦੇ ਹਾਂ ਅਤੇ API ਨੂੰ ਇੱਕ ਫਾਇਲ ਹੈਂਡਲ ਖੋਲਦੇ ਹਾਂ. ਅਸੀਂ ਹੈਂਡਲ ਨੂੰ ਸਿਰਫ-ਪੜਨ ਲਈ ਖੋਲ ਸਕਦੇ ਹਾਂ ਕਿਉਂਕਿ ਪ੍ਰਸੰਗ ਲਿਖਣ ਦਾ ਧਿਆਨ ਰੱਖਦਾ ਹੈ.

ਸਿਮਟਲ ਉਹ ਚੀਜ਼ਾਂ ਦਾ ਭੰਡਾਰ ਹੈ ਜੋ ਅਸੀਂ ਅਨੁਕੂਲ ਬਣਾ ਸਕਦੇ ਹਾਂ, ਇਸ ਲਈ ਜੇਕਰ ਤੁਸੀਂ ਹੋਰ ਜਾਣਨਾ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ਦਸਤਾਵੇਜ਼ਾਂ ਦੀ ਜਾਂਚ ਕਰਨਾ ਵਧੀਆ ਹੈ.

ਕਸਟਮ ਪਰੋਟੋਕੋਲ ਅਤੇ ਫਿਲਟਰ ਬਣਾਉਣਾ

ਸੰਮਿਲਿਤ ਹੋਣ ਨਾਲ ਅਸੀਂ ਚੀਜ਼ਾਂ ਨੂੰ ਲਪੇਟਦੇ ਹਾਂ, ਆਓ ਕਸਟਮ ਪ੍ਰੋਟੋਕੋਲ ਬਣਾਉਣ ਬਾਰੇ ਗੱਲ ਕਰੀਏ. ਬਹੁਤ ਸਾਰਾ ਕੰਮ ਜੋ ਕਿ ਕੀਤੇ ਜਾਣ ਦੀ ਲੋੜ ਹੈ ਪਰ ਇਕ ਵਾਰ ਉਹ ਕੰਮ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਸੀਂ ਆਪਣੀ ਸਟ੍ਰੀਮ ਰੈਪਰ ਨੂੰ ਕਾਫ਼ੀ ਆਸਾਨੀ ਨਾਲ ਰਜਿਸਟਰ ਕਰ ਸਕਦੇ ਹਾਂ:

     ਜੇ (ਇਨ_ਰੇਅ ("ਹਾਈਲਾਈਟ-ਨਾਮ", ਸਟ੍ਰੀਮ_ਗਟ_ਰੇਪਰ   )) {stream_wrapper_unregister ("ਹਾਈਲਾਈਟ-ਨਾਮ");}stream_wrapper_register ("ਹਾਈਲਾਈਟ-ਨਾਮ", "ਹਾਈਲਾਈਟਨਾਮਪਰੋਟੋਕੋਲ");$ highlighted = file_get_contents ("ਹਾਈਲਾਈਟ-ਨਾਮ: // ਕਹਾਣੀ. txt");    

ਮਿਡਲ, ਕਸਟਮ ਸਟ੍ਰੀਮ ਫਿਲਟਰਸ ਬਣਾਉਣਾ ਵੀ ਸੰਭਵ ਹੈ. ਦਸਤਾਵੇਜ਼ਾਂ ਵਿੱਚ ਇੱਕ ਉਦਾਹਰਨ ਫਿਲਟਰ ਕਲਾਸ ਹੈ:

     ਫਿਲਟਰ {ਜਨਤਕ $ filtername;ਜਨਤਕ $ paramsਪਬਲਿਕ ਇੰਟ ਫਿਲਟਰ (ਸਰੋਤ $ ਵਿੱਚ, ਸਰੋਤ $ ਬਾਹਰ, ਇੰਟੇਲ ਅਤੇ $ ਖਪਤ,ਬੂਲ $ ਬੰਦ ਕਰਨਾ)ਜਨਤਕ ਰੱਦ ਕਰਨ ਤੇ (ਬੰਦ) ਰੱਦ ਕਰੋਜਨਤਕ bool onCreate (ਰੱਦਕੀਤਾ)}    

ਇਸ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਦਰਜ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:

     $ ਹੈਂਡਲ = ਫੋਪੇਨ ("ਕਹਾਣੀ. Txt", "w +");stream_filter_append ($ ਹੈਂਡਲ, "ਹਾਈਲਾਈਟ-ਨਾਮ", STREAM_FILTER_READ);    

ਉਚਾਈ-ਨਾਂ ਨੂੰ ਫਿਲਡੇਂਮ ਨਾਲ ਨਵੇਂ ਫਿਲਟਰ ਕਲਾਸ ਦੀ ਸੰਪਤੀ ਨਾਲ ਮੇਲ ਕਰਨ ਦੀ ਲੋੜ ਹੈ. php: // filter / highligh-names / resource = story ਵਿੱਚ ਕਸਟਮ ਫਿਲਟਰਸ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਵੀ ਸੰਭਵ ਹੈ. txt ਸਤਰ ਪਰੋਟੋਕਾਲਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਨਾਲੋਂ ਫਿਲਟਰਜ਼ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਬਹੁਤ ਆਸਾਨ ਹੈ. ਇਸਦਾ ਇਕ ਕਾਰਨ ਇਹ ਹੈ ਕਿ ਪ੍ਰੋਟੋਕਾਲਾਂ ਨੂੰ ਡਾਇਰੈਕਟਰੀ ਕਾਰਵਾਈਆਂ ਨੂੰ ਸੰਭਾਲਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਜਦੋਂ ਕਿ ਫਿਲਟਰਾਂ ਨੂੰ ਸਿਰਫ ਡਾਟਾ ਦੇ ਹਰੇਕ ਭਾਗ ਨੂੰ ਸੰਭਾਲਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ.

ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਜਜ਼ਬਾਤੀ ਹੈ, ਤਾਂ ਮੈਂ ਤੁਹਾਨੂੰ ਉਤਸ਼ਾਹਿਤ ਕਰਦਾ ਹਾਂ ਕਿ ਤੁਸੀਂ ਕਸਟਮ ਪ੍ਰੋਟੋਕੋਲ ਅਤੇ ਫਿਲਟਰ ਬਣਾਉਣ ਦੇ ਨਾਲ ਪ੍ਰਯੋਗ ਕਰੋ. ਜੇ ਤੁਸੀਂ stream_copy_to_stream ਕਾਰਵਾਈਆਂ ਲਈ ਫਿਲਟਰਾਂ ਨੂੰ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਡੀਆਂ ਐਪਲੀਕੇਸ਼ਨ ਅਸ਼ਲੀਲ ਵੱਡੀਆਂ ਫਾਈਲਾਂ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਵੇਲੇ ਵੀ ਮੈਮੋਰੀ ਤੋਂ ਅੱਗੇ ਵਰਤਣ ਜਾ ਰਹੇ ਹਨ ਕਲਪਨਾ ਕਰੋ ਕਿ ਮੁੜ-ਅਕਾਰ-ਚਿੱਤਰ ਫਿਲਟਰ ਲਿਖੋ ਅਤੇ ਏਨਕ੍ਰਿਪਟ-ਲਈ-ਐਪਲੀਕੇਸ਼ਨ ਫਿਲਟਰ.

ਸੰਖੇਪ

ਸੈਮਟ੍ਰਟ ਇਹ ਇੱਕ ਸਮੱਸਿਆ ਨਹੀਂ ਹੈ ਜਿਸਦਾ ਅਕਸਰ ਸਾਨੂੰ ਦੁੱਖ ਹੁੰਦਾ ਹੈ, ਵੱਡੀਆਂ ਫਾਈਲਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਗੜਬੜ ਕਰਨਾ ਸੌਖਾ ਹੁੰਦਾ ਹੈ ਅਸਿੰਕਰੋਨਸ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ, ਜਦੋਂ ਅਸੀਂ ਮੈਮੋਰੀ ਵਰਤੋਂ ਬਾਰੇ ਸਾਵਧਾਨ ਨਹੀਂ ਹੁੰਦੇ ਤਾਂ ਪੂਰੇ ਸਰਵਰ ਨੂੰ ਹੇਠਾਂ ਲਿਆਉਣ ਲਈ ਇਹ ਆਸਾਨ ਹੈ.

ਇਹ ਟਿਊਟੋਰਿਅਲ ਨੇ ਉਮੀਦ ਜਤਾਈ ਹੈ ਕਿ ਤੁਸੀਂ ਕੁਝ ਨਵੇਂ ਵਿਚਾਰਾਂ (ਜਾਂ ਉਹਨਾਂ ਬਾਰੇ ਤੁਹਾਡੀ ਮੈਮੋਰੀ ਨੂੰ ਤਾਜ਼ਾ ਕੀਤਾ), ਤਾਂ ਜੋ ਤੁਸੀਂ ਇਸ ਬਾਰੇ ਹੋਰ ਸੋਚ ਸਕੋ ਕਿ ਵੱਡੇ ਫਾਈਲਾਂ ਨੂੰ ਪ੍ਰਭਾਵੀ ਢੰਗ ਨਾਲ ਕਿਵੇਂ ਪੜ੍ਹਿਆ ਅਤੇ ਲਿਖਾਓ. ਜਦੋਂ ਅਸੀਂ ਸਟ੍ਰੀਮਜ਼ ਅਤੇ ਜਨਰੇਟਰਾਂ ਤੋਂ ਜਾਣੂ ਹੋਣਾ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ, ਅਤੇ file_get_contents ਵਰਗੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਵਰਤਣਾ ਬੰਦ ਕਰ ਦਿੰਦੇ ਹੋ: ਸਾਡੇ ਐਪਲੀਕੇਸ਼ਨਾਂ ਤੋਂ ਸਾਰੀਆਂ ਸ਼੍ਰੇਣੀਆਂ ਦੀਆਂ ਗਲਤੀਆਂ ਅਲੋਪ ਹੋ ਜਾਂਦੀਆਂ ਹਨ ਇਹ ਨਿਸ਼ਾਨਾ ਬਣਾਉਣ ਲਈ ਚੰਗੀ ਗੱਲ ਹੈ!

March 1, 2018