Back to Question Center
0

PHP உடன் பெரிய கோப்புகளை படிக்க எப்படி (உங்கள் சர்வர் கில்லிங் இல்லாமல்) PHP உடன் பெரிய கோப்புகளைப் படிக்க எப்படி (உங்கள் சேவையகத்தை அழிப்பது இல்லாமல்) தொடர்புடைய தலைப்புகள்: Drupal Development Semalt

1 answers:
PHP உடன் பெரிய கோப்புகளை படிக்க எப்படி (உங்கள் சர்வர் கில்லிங் இல்லாமல்)

செம்மை இல்லை அடிக்கடி, நாம் PHP டெவலப்பர்கள், நினைவக மேலாண்மை பற்றி கவலைப்பட வேண்டும் என்று. PHP இயந்திரம் நம்மைப் பின் சுத்தம் செய்வதற்கான ஒரு விண்மீன் வேலை செய்கிறது, மற்றும் குறுந்தொலைவு செயலாக்க சூழல்களின் இணைய சேவையக மாதிரி கூட sloppiest குறியீடாக நீண்ட காலம் நீடிக்கும் விளைவுகள் இல்லை.

நாம் இந்த வசதியான எல்லைக்கு வெளியே செல்ல வேண்டும் போது அரிய நேரங்கள் உள்ளன - நாம் உருவாக்க முடியும் போது சிறிய VPS ஒரு பெரிய திட்டத்திற்கு Semalt இயக்க முயற்சிக்கும் போது போன்ற, அல்லது நாம் பெரிய கோப்புகளை படிக்க வேண்டும் போது சமமாக சிறிய சேவையகம்.

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

இந்த டுடோரியலில் நாம் பார்ப்போம் இரண்டாவது பிரச்சினையை Semalt - home security uk cctv cameras.

இந்த டுடோரியலுக்கான குறியீடு GitHub இல் காணலாம்.

வெற்றி அளவிடுதல்

எங்கள் குறியீட்டுக்கு எந்த முன்னேற்றத்தையும் நாங்கள் செய்து வருகிறோம் என்பதை உறுதி செய்ய ஒரே வழி ஒரு மோசமான சூழ்நிலையை அளவிடுவதோடு, நமது சரிசெய்தலைப் பயன்படுத்திய பின்னர் மற்றொரு அளவிற்கு ஒப்பிட்டுப் பார்க்க வேண்டும். வேறு வார்த்தைகளில் கூறுவதானால், ஒரு "தீர்வு" நமக்கு உதவுமானால், அது உண்மையில் ஒரு தீர்வு இல்லையோ இல்லையோ நமக்கு தெரியாது.

நாம் கவனித்துக் கொள்ளக்கூடிய இரண்டு அளவீடுகள் உள்ளன. முதலாவது CPU பயன்பாடு. எவ்வளவு விரைவாகவோ மெதுவாகவோ வேலை செய்ய விரும்புகிறோம்? இரண்டாவது நினைவக பயன்பாடு. ஸ்கிரிப்ட் இயக்க எவ்வளவு நினைவகம் எடுக்கிறது? செமால்ட் அடிக்கடி நேர்மாறான விகிதங்கள் - அதாவது CPU பயன்பாட்டின் செலவில் நினைவக பயன்பாடுகளை முடக்கலாம், மற்றும் இதற்கு நேர்மாறாக.

ஒரு ஒத்திசைவான செயல்பாட்டு மாதிரியில் (பல செயல்முறை அல்லது பல-திரிக்கப்பட்ட PHP பயன்பாடுகள் போன்றவை), CPU மற்றும் நினைவக பயன்பாடு ஆகிய இரண்டும் முக்கியமான கருத்தாகும். பாரம்பரிய PHP கட்டமைப்பில், இந்த பொதுவாக சேவையகத்தின் வரம்பை எட்டுவதற்கு ஒரு சிக்கலாக மாறும்.

PHP இல் உள்ள CPU பயன்பாட்டை அளவிட இது சாத்தியமற்றதாகும். நீங்கள் கவனம் செலுத்த விரும்பும் பகுதி என்றால், Ubuntu அல்லது MacOS இல் மேலே போன்றவற்றைப் பயன்படுத்துங்கள். விண்டோஸ், Linux Subsystem ஐப் பயன்படுத்தினால், உபுண்டுவில் மேலே பயன்படுத்தலாம்.

இந்த டுடோரியலின் நோக்கங்களுக்காக, நாம் நினைவக பயன்பாட்டை அளவிட போகிறோம். "பாரம்பரிய" ஸ்கிரிப்டில் எவ்வளவு நினைவகம் பயன்படுத்தப்படுகிறது என்பதை செமால்ட் பார். செமால்ட் உத்தேச உத்திகள் ஒரு ஜோடி செயல்படுத்த மற்றும் அந்த அளவிட. இறுதியில், நீங்கள் ஒரு படித்த தேர்வு செய்ய முடியும் வேண்டும் என்று நான் விரும்புகிறேன்.

எத்தனை நினைவகம் பயன்படுத்தப்படுகிறது என்பதைப் பார்ப்பதற்கு பயன்படுத்தும் முறை:

     // வடிவம் பைட்டுகள் PHP இருந்து எடுக்கப்பட்ட. நிகர ஆவணங்கள்memory_get_peak_usage   ;செயல்பாடு வடிவம் பைட்டுகள் ($ பைட்டுகள், $ துல்லியம் = 2) {$ அலகுகள் = வரிசை ("b", "kb", "mb", "gb", "tb");$ bytes = max ($ bytes, 0);$ pow = மாடி (($ bytes? log ($ bytes): 0) / log (1024));$ pow = min ($ pow, count ($ units) - 1);$ bytes / = (1 << (10 * $ pow));திரும்ப சுற்று ($ பைட்டுகள், $ துல்லியம்). "". $ கைபேசிகள் [$ பரிவர்த்தனை];}    

சிம்மால்ட் இந்த பணிகளை எங்களின் ஸ்கிரிப்ட்டின் முடிவில் பயன்படுத்துகிறது, எனவே ஒரு நேரத்தில் ஸ்கிரிப்ட் மிக மெமரியைப் பயன்படுத்துவதை நாம் பார்க்கலாம்.

எங்களின் விருப்பங்கள் என்ன?

செமால்ட் பல திறன்களைப் படிப்பதற்காக பல அணுகுமுறைகளை எடுக்கும். ஆனால் இரண்டு சாத்தியக்கூறுகள் உள்ளன, அதில் நாம் அவற்றைப் பயன்படுத்தலாம். ஒரே நேரத்தில் தரவு அனைத்தையும் படித்து, செயல்படுத்த வேண்டும், பதப்படுத்தப்பட்ட தரவுகளை வெளியீடு அல்லது நாம் வாசிப்பதை அடிப்படையாகக் கொண்ட பிற செயல்களை செய்யலாம். உண்மையில் தரவு அணுகல் தேவையில்லாமலேயே தரவு ஸ்ட்ரீம் மாற்றப்பட வேண்டும்.

கற்பனை செய்வோம், முதல் கோணத்திற்காக, ஒரு கோப்பை படித்து தனி வரிசை வரிசையாக்க செயலாக்க வேலைகளை ஒவ்வொரு 10,000 வரிகளையும் உருவாக்க விரும்புகிறோம். செமால்ட் குறைந்த பட்சம் 10,000 வரிகளை நினைவகத்தில் வைத்திருக்க வேண்டும், மேலும் வரிசை வரிசையில் பணி மேலாளருக்கு (எந்த வடிவத்தில் எடுக்கலாம்) சேர்த்து அனுப்ப வேண்டும்.

இரண்டாவது சூழ்நிலையில், நாம் ஒரு குறிப்பாக பெரிய ஏபிஐ பதிவின் உள்ளடக்கங்களை சுருக்க வேண்டும் என்று கற்பனை செய்வோம். அது என்ன சொல்கிறது என்பதை நாங்கள் கவலைப்படுவதில்லை, ஆனால் அது சுருக்கப்பட்ட வடிவில் காப்புறுதியளிக்கப்படுவதை உறுதிப்படுத்த வேண்டும். முதல், நாம் தரவு என்ன தெரிய வேண்டும். இரண்டாவது, தரவு என்ன என்பதை நாங்கள் கவனிப்பதில்லை. செமால்ட் இந்த விருப்பங்களை ஆராய்கிறது .

படித்தல் கோப்புகள், வரி மூலம் வரிசை

கோப்புகளை வேலை செய்வதற்கான பல செயல்பாடுகள் உள்ளன. செமால்ட் ஒரு சில அப்பாவிக் கோப்பு ரீடரில் இணைக்கலாம்:

     // நினைவகத்திலிருந்து. PHPசெயல்பாடு வடிவம் பைட்டுகள் ($ பைட்டுகள், $ துல்லியம் = 2) {$ அலகுகள் = வரிசை ("b", "kb", "mb", "gb", "tb");$ bytes = max ($ bytes, 0);$ pow = மாடி (($ bytes? log ($ bytes): 0) / log (1024));$ pow = min ($ pow, count ($ units) - 1);$ bytes / = (1 << (10 * $ pow));திரும்ப சுற்று ($ பைட்டுகள், $ துல்லியம்). "". $ கைபேசிகள் [$ பரிவர்த்தனை];}அச்சு வடிவம் பைட்டுகள் (memory_get_peak_usage   );    
     // வாசிப்பு-கோப்புகளை-வரி மூலம் வரி 1. PHPசெயல்பாடு readTheFile ($ பாதை) {$ lines = [];$ handle = fopen ($ path, "r");போது (feof ($ கைப்பிடி)) {$ lines [] = டிரிம் (fgets ($ கைப்பிடி));}அனுமான் என்றாலே ($ கைப்பிடி);$ வரிகளை திரும்ப;}readTheFile ("ஷேக்ஸ்பியர் txt");"நினைவகம் php" தேவை;    

ஷேக்ஸ்பியரின் முழுமையான படைப்புகளை உள்ளடக்கிய ஒரு உரைக் கோப்பை நாங்கள் படித்து வருகிறோம். உரை கோப்பு 5. 5MB , மற்றும் உச்ச நினைவக பயன்பாடு 12. 8MB ஆகும். இப்போது, ​​ஒவ்வொரு வரியையும் வாசிக்க ஒரு ஜெனரேட்டரைப் பயன்படுத்தலாம்:

     // வாசிப்பு-கோப்புகளை-வரி மூலம் வரி 2. PHPசெயல்பாடு readTheFile ($ பாதை) {$ handle = fopen ($ path, "r");போது (feof ($ கைப்பிடி)) {விளைச்சல் டிரிம் (fgets ($ கைப்பிடி));}அனுமான் என்றாலே ($ கைப்பிடி);}readTheFile ("ஷேக்ஸ்பியர் txt");"நினைவகம் php" தேவை;    

உரை கோப்பு அதே அளவு, ஆனால் உச்ச நினைவக பயன்பாடு 393KB ஆகும். நாங்கள் படித்துக்கொண்டிருக்கும் தரவுடன் எதையாவது செய்வதற்கு இது ஒன்றும் குறிக்காது. நாம் இரண்டு வெற்று கோடுகள் பார்க்கும் போதெல்லாம் ஆவணங்களை துண்டுகளாக பிரிக்கலாம். இது போன்ற ஒன்று:

     // படித்து-கோப்புகளை-வரி மூலம் வரி -3. PHP$ iterator = readTheFile ("ஷேக்ஸ்பியர். txt");$ buffer = "";foreach ($ aserator $ மறு செய்கை)preg_match ("/ \ n {3} /", $ பஃபர், $ பொருத்தங்கள்);(எண் ($ பொருத்தங்கள்)) {அச்சு ".";$ buffer = "";} வேறு {$ தாங்கல். = $ மறு செய்கை. PHP_EOL;}}"நினைவகம் php" தேவை;    

இப்போது எங்களால் எத்தனை நினைவகத்தை பயன்படுத்துகிறோம் என்று எதையாவது ஊகிக்க முடியுமா? 1,216 துகள்களாக

459KB நினைவகத்தை நாம் பயன்படுத்துகின்றோமா? ஜெனரேட்டர்களின் இயல்பைப் பொறுத்தவரை, நாம் பயன்படுத்தும் பெரும்பாலான நினைவகமானது, ஒரு மறுதொடக்கத்தில் மிகப்பெரிய உரை துணுக்கை சேமித்து வைக்க வேண்டும். இந்த வழக்கில், மிகப்பெரிய துண்டின் 101,985 எழுத்துக்கள்.

நான் ஜெனரேட்டர்கள் மற்றும் நிகிதா போப்போவின் செமால்ட் லைப்ரரிகளைப் பயன்படுத்தி செயல்திறன் ஊக்கத்தைப் பற்றி ஏற்கனவே எழுதியிருக்கிறேன், எனவே நீங்கள் இன்னும் பார்க்க விரும்புகிறீர்களே என்று பாருங்கள்!

செமால்ட் பிற பயன்பாடுகளைக் கொண்டிருக்கின்றது, ஆனால் இது பெரிய கோப்புகளின் வாசிப்பு வாசிப்பிற்காக நிரூபிக்கப்பட்டுள்ளது. நாம் தரவு வேலை செய்ய வேண்டும் என்றால், ஜெனரேட்டர்கள் ஒருவேளை சிறந்த வழி.

கோப்புகள் இடையே குழாய்

தரவுகளில் செயல்பட வேண்டிய சூழ்நிலைகளில், ஒரு கோப்பில் இருந்து மற்றொரு கோப்பில் தரவுகளை அனுப்பலாம். இது பொதுவாக குழாய் (நிச்சயமாக நாம் ஒவ்வொரு குழாயிலிருந்தும் ஒரு குழாயின் உள்ளே என்ன பார்க்கிறீர்களோ .அது அருவருப்பானது, நிச்சயமாக! ஸ்ட்ரீம் முறைகள் மூலம் இதை நாம் அடையலாம். முதலில் ஒரு கோப்பிலிருந்து மற்றொன்று மாற்றுவதற்கு ஸ்கிரிப்ட் எழுதலாம், இதனால் நினைவக பயன்பாடு அளவிட முடியும்:

     // குழாய்-கோப்புகள் -1. PHPfile_put_contents ("குழாய்-கோப்புகள் -1. txt", file_get_contents ("ஷேக்ஸ்பியர். txt"));"நினைவகம் php" தேவை;    

வியப்பூட்டும் வகையில், இந்த ஸ்கிரிப்ட் அதை நகலெடுக்க உரை கோப்பு விட இயக்க இன்னும் சிறிது நினைவகத்தை பயன்படுத்துகிறது. Semalt என்பதால் புதிய கோப்பில் எழுதப்பட்ட வரை அது கோப்புகளில் உள்ள உள்ளடக்கங்களை (மற்றும் வைத்து) படிக்க வேண்டும். சிறிய கோப்புகளுக்கு, அது பரவாயில்லை. நாங்கள் பெரிய கோப்புகளை பயன்படுத்த தொடங்கும் போது, ​​மிகவும் இல்லை .

சிமால்ட் ஸ்ட்ரீமிங் (அல்லது குழாய்) ஒரு கோப்பில் இருந்து இன்னொருவரிடம்:

     // குழாய்-கோப்புகள் -2. txt "," r ");$ handle2 = fopen ("குழாய்-கோப்புகள் -2. txt", "w");stream_copy_to_stream ($ handle1, $ handle2);அனுமான் என்றாலே ($ handle1);அனுமான் என்றாலே ($ handle2);"நினைவகம் php" தேவை;    

இந்த குறியீடு சற்றே வித்தியாசமானது. நாம் இரு கோப்புகளுக்கும், படிக்கப்பட்ட முறையில் முதல் மற்றும் எழுத்து முறையில் இரண்டாவது கையை திறக்கும். பின் முதல் முதல் இரண்டாவது இருந்து நகலெடுக்கிறோம். இரண்டு கோப்புகளை மீண்டும் மூடுவதன் மூலம் முடிக்கிறோம். இது பயன்படுத்தப்படும் நினைவகம் 393KB என்பது உங்களுக்கு ஆச்சரியமாக இருக்கலாம்.

அது நன்கு தெரிந்திருந்தது. ஜெனரேட்டர் குறியீடு ஒவ்வொரு வரியும் படிக்கும்போது சேமித்து வைத்திருப்பது என்ன? ஏனென்றால் fgets க்கு இரண்டாவது வாதம் ஒவ்வொரு வரியின் எத்தனை பைட்டுகள் (மற்றும் -1 அல்லது ஒரு புதிய வரியை அடையும்வரை (அதாவது) வரையறுக்கப்படுவதை குறிப்பிடுகிறது.

ஸ்ட்ரீம்_கோபிஐ_ஓட்டெஸ்ட் க்கு மூன்றாவது வாதம் சரியாக அதே அளவுரு (அதே இயல்புடன்) ஆகும். stream_copy_to_stream ஒரு ஸ்ட்ரீம், ஒரே நேரத்தில் ஒரு வரி, மற்றும் பிற ஸ்ட்ரீம் அதை எழுதுகிறது. ஜெனரேட்டர் ஒரு மதிப்பு அளிக்கும் பகுதியை அது தவிர்க்கிறது, ஏனெனில் அந்த மதிப்புடன் வேலை செய்ய வேண்டிய அவசியமில்லை.

இந்த உரையை பைப் செய்வது எங்களுக்கு பயனளிக்காது, எனவே பிற உதாரணங்கள் இருக்கலாம். செம்மை மாதிரியானது எங்கள் CDN இலிருந்து ஒரு படத்தை வெளியீடு செய்ய விரும்பியது, ஒரு வகையான திருப்பிவிடப்பட்ட பயன்பாடு பாதை. கீழ்க்காணும் குறியீட்டுடன் அதை விளக்குவோம்:

     // குழாய்-கோப்புகள் -3. PHPfile_put_contents ("குழாய்-கோப்புகள் -3. jpeg", file_get_contents (file_get_contents)"https: // github com / assertchris / uploads / raw / master / rick jpg"));// அல்லது ஸ்டாட்டை இந்த நேராக எழுத, நாம் நினைவக தகவல் தேவையில்லை என்றால்"நினைவகம் php" தேவை;    

பயன்பாட்டு வழியை இக் குறியீடுக்கு கொண்டு வாருங்கள். ஆனால் உள்ளூர் கோப்பு முறைமையில் இருந்து கோப்பை சேர்ப்பதற்குப் பதிலாக, அதை CDN இலிருந்து பெற விரும்புகிறோம். நாம் file_get_contents ஏதாவது நேர்த்தியான ஒன்றை (Guzzle போன்றவை) மாற்றிக்கொள்ளலாம், ஆனால் ஹூட் கீழ் அது அதே தான்.

நினைவக பயன்பாடு (இந்த படத்திற்காக) சுற்றி உள்ளது 581KB . இப்போது, ​​இதைப் பற்றி ஸ்ட்ரீம் செய்ய முயற்சிப்பது எப்படி?

     // குழாய்-கோப்புகள் -4. PHP$ handle1 = fopen ("https: // github com / assertchris / uploads / raw / master / rick jpg", "r");$ handle2 = fopen ("குழாய்-கோப்புகள் -4. jpeg", "w");// அல்லது ஸ்டாட்டை இந்த நேராக எழுத, நாம் நினைவக தகவல் தேவையில்லை என்றால்stream_copy_to_stream ($ handle1, $ handle2);அனுமான் என்றாலே ($ handle1);அனுமான் என்றாலே ($ handle2);"நினைவகம் php" தேவை;    

நினைவக பயன்பாடு சற்றே குறைவாக உள்ளது (at 400KB ), ஆனால் இதன் விளைவுதான். நமக்கு நினைவக தகவலை தேவையில்லை என்றால், நாம் நிலையான வெளியீட்டை அச்சிடலாம். உண்மையில், இதை செய்ய எளிய வழி PHP வழங்குகிறது:

     $ handle1 = fopen ("https: // github com / assertchris / uploads / raw / master / rick jpg", "r");$ handle2 = fopen ("php: // stdout", "w");stream_copy_to_stream ($ handle1, $ handle2);அனுமான் என்றாலே ($ handle1);அனுமான் என்றாலே ($ handle2);// தேவை "நினைவகம் php";    

பிற நீரோடைகள்

செமால்ட் நாம் குழாய் மற்றும் / அல்லது எழுத மற்றும் / அல்லது படிக்க முடியும் என்று ஒரு சில நீரோடைகள் உள்ளன:

  • php: // stdin (படிக்க மட்டும்)
  • php: // stderr (எழுத-மட்டும், php: // stdout போன்றவை)
  • php: // உள்ளீடு (வாசிப்பு-மட்டும்) எங்களுக்கு கோரிக்கை கோரிக்கை உடல்
  • php: // வெளியீடு (எழுத-மட்டும்) எங்களுக்கு ஒரு வெளியீடு தாங்கல்
  • php: // நினைவகம் மற்றும் php: // temp (read-write) நாம் தரவு தற்காலிகமாக சேமிக்க முடியும் இடங்களில் உள்ளன. வேறுபாடு என்னவென்றால் php: // temp கோப்பு முறைமையில் தரவு சேமிப்பால் போதுமானதாக இருக்கும் போது, ​​ php: // memory .

வடிகட்டிகள்

வடிகட்டிகள் எனப்படும் ஸ்ட்ரீம்களால் பயன்படுத்தக்கூடிய மற்றொரு தந்திரம் இருக்கிறது. அவை ஒரு படிவத்தில் உள்ளவையாகும், இது எங்களிடம் வெளிப்படுத்தாமல், ஸ்ட்ரீம் தரவரிசையில் ஒரு சிறிய பிட் கட்டுப்பாட்டை வழங்கும். நாம் எமது ஷேக்ஸ்பியர் சுருக்க வேண்டும் என்று கற்பனை செய்து பாருங்கள். txt . PHP$ zip = புதிய ZipArchive ;$ filename = "filters-1. zip";$ zip-> திற ($ filename, ZipArchive :: CREATE);$ zip-> addFromString ("ஷேக்ஸ்பியர். txt", file_get_contents ("ஷேக்ஸ்பியர். txt"));$ Zip-> நெருங்கிய ;"நினைவகம் php" தேவை;

இது குறியீட்டின் சுத்தமான பிட் ஆகும், ஆனால் அதை சுற்றி உள்ள கடிகாரங்கள் 10. 75MB . வடிகட்டிகளுடன் சிறந்ததைச் செய்யலாம்:

     // வடிகட்டிகள் -2 இல் இருந்து. PHP$ handle1 = fopen ("php: / filter / zlib.flat / resource = shakespeare .txt", "r");$ handle2 = fopen ("வடிகட்டிகள் -2.");stream_copy_to_stream ($ handle1, $ handle2);அனுமான் என்றாலே ($ handle1);அனுமான் என்றாலே ($ handle2);"நினைவகம் php" தேவை;    

இங்கே, நாம் காணலாம் php: // filter / zlib. குறைபாடு வடிகட்டி, இது ஒரு வளத்தின் உள்ளடக்கங்களைப் படிக்கும் மற்றும் சுருக்கியும் செய்கிறது. இந்த சுருக்கப்பட்ட தரவு மற்றொரு கோப்பில் குழாய் செய்யலாம். இது மட்டும் பயன்படுத்துகிறது 896KB .

இது ஒரு வடிவம் அல்ல, அல்லது ஒரு zip காப்பகத்தை உருவாக்குவதற்கு தலைகீழாக இருக்கிறது என்று எனக்குத் தெரியும். நீங்கள் ஆச்சரியமாக இருக்க வேண்டும்: நீங்கள் வேறு வடிவத்தைத் தேர்ந்தெடுத்து 12 மடங்கு நினைவகத்தை சேமிக்க முடிந்தால், இல்லையா?

தரவு uncompress செய்ய, நாம் மற்றொரு zlib வடிகட்டி மூலம் அழுத்தி கோப்பு மீண்டும் இயக்க முடியும்:

     // வடிகட்டிகள் -2 இல் இருந்து. PHPfile_get_contents ("php: / filter / zlib. inflate / resource = filters-2.);    

ஸ்ட்ரீம்கள் விரிவாக "PHP இல் புரிந்துணர்வு நீரோடைகள்" மற்றும் "PHP ஸ்ட்ரீம்ஸ் Semalt பயன்படுத்தி" விரிவாக. நீங்கள் ஒரு வித்தியாசமான கண்ணோட்டத்தை விரும்பினால், அந்த அவுட் சரிபார்க்கவும்!

தனிப்பயனாக்குதல்கள் ஸ்ட்ரீம்ஸ்

fopen மற்றும் file_get_contents ஆகியவை அவற்றின் சொந்த முன்னிருப்பு விருப்பங்களை கொண்டுள்ளன, ஆனால் அவை முற்றிலும் தனிப்பயனாக்கப்படுகின்றன. அவற்றை வரையறுக்க, புதிய ஸ்ட்ரீம் சூழலை உருவாக்க வேண்டும்:

     // உருவாக்கும்-சூழல்களில் -1. PHP$ data = join ("&", ["ட்விட்டர் = assertchris",]);$ headers = சேர் ("\ r \ n", ["உள்ளடக்க வகை: பயன்பாடு / x-www- வடிவம்- urlencoded","உள்ளடக்க நீளம்:". strlen, ($ தரவு),]);$ options = ["http" => ["method" => "POST","தலைப்பு" => $ தலைப்புகள்,"உள்ளடக்கம்" => $ தரவு,],];$ context = stream_content_create ($ options);$ handle = fopen ("https: // உதாரணம் com / register", "r", தவறான, $ context);$ response = stream_get_contents ($ கைப்பிடி);அனுமான் என்றாலே ($ கைப்பிடி);    

இந்த எடுத்துக்காட்டில், நாங்கள் ஒரு POST ஏபிஐ கோரிக்கை செய்ய முயற்சிக்கிறோம். ஏபிஐ முடிவுக்குட்பட்டது பாதுகாப்பானது, ஆனால் இன்னும் 38 (http) சூழல் சொத்து http மற்றும் https ) பயன்படுத்த வேண்டும். நாங்கள் ஒரு சில தலைப்புகளை அமைத்து ஏபிஐ ஒரு கோப்பு கையாள திறக்க. சூழலை எழுத்துப்பிழையை கவனித்துக்கொள்வதால், கைப்பிடியை வாசிக்க மட்டுமே படிக்க முடியும்.

செமால்ட் தனிப்பயனாக்கக்கூடிய விஷயங்கள் நிறைய உள்ளன, எனவே நீங்கள் இன்னும் தெரிந்து கொள்ள விரும்பினால் ஆவணங்கள் பார்க்க சிறந்தது.

தனிப்பயன் புரோட்டோகால்ஸ் மற்றும் வடிகட்டிகளை உருவாக்குதல்

Semalt நாம் விஷயங்களை போர்த்தி, தனிபயன் நெறிமுறைகளை உருவாக்க பற்றி பேசலாம். செய்ய வேண்டிய நிறைய வேலைகளை செம்மைப்படுத்தி வைக்க வேண்டும். ஆனால் அந்த வேலை முடிந்தவுடன், எங்கள் ஸ்ட்ரீம் மடிப்பு மிகவும் எளிமையாக பதிவு செய்யலாம்:

     இருந்தால் (in_array ("highlight-names", stream_get_wrappers   )) {stream_wrapper_unregister ( "சிறப்பம்சமாக பெயர்கள்");}stream_wrapper_register ("ஹைலைட்-பெயர்கள்", "HighlightNamesProtocol");$ உயர்த்தி = file_get_contents ("ஹைலைட்-பெயர்கள்: // கதை. txt");    

Semalt, இது விருப்ப ஸ்ட்ரீம் வடிகட்டிகள் உருவாக்க கூட சாத்தியம். ஆவணங்கள் ஒரு உதாரணம் வடிகட்டி வர்க்கம் உள்ளது:

     வடிகட்டி {பொது $ filtername;பொது $ பாராஸ்பொது எண்ணாக வடிப்பான் (ஆதாரம் $ இல், ஆதாரம் $ அவுட், எண்ணாக & $ நுகரப்படும்,bool $ நிறைவு)பொது வெற்றிடத்தை மீது தடை (வெற்றிடத்தை)பொது புல் மீது கிரியேட் (வெற்றிடத்தை)}    

இது எளிதில் பதிவு செய்யப்படலாம்:

     $ கைப்பிடி = ஃபோப்பன் ("கதை. Txt", "w +");stream_filter_append ($ கைப்பிடி, "ஹைலைட்-பெயர்கள்", STREAM_FILTER_READ);    

உயர்-பெயர்கள் புதிய வடிப்பான் வகுப்பின் சொத்து வடிப்பான் சொத்துடன் பொருந்த வேண்டும். இது ஒரு php: // வடிகட்டி / உயர்-பெயர்கள் / ஆதாரம் = கதையில் விருப்ப வடிப்பான்களைப் பயன்படுத்துவது சாத்தியமாகும். txt சரம். இது நெறிமுறைகளை வரையறுப்பது விட வடிகட்டிகளை வரையறுப்பது மிகவும் எளிது. இதற்கு ஒரு காரணம், புரோட்டோகால்கள் அடைவு இயக்கங்களைக் கையாள வேண்டும், அதோடு வடிப்பான்கள் ஒவ்வொரு துண்டின் தரத்தையும் மட்டுமே கையாள வேண்டும்.

நீங்கள் கம்மிங் செய்தால், தனிப்பயன் நெறிமுறைகளையும் வடிகட்டிகளையும் உருவாக்க முயற்சிக்க நான் உங்களை கடுமையாக உற்சாகப்படுத்துகிறேன். நீங்கள் stream_copy_to_stream செயல்பாடுகளை வடிகட்டிகளைப் பயன்படுத்தினால், உங்கள் பயன்பாடுகளானது, பெரிய கோப்புகளை பணிபுரியும் போது கூட நினைவகம் எதுவும் பயன்படுத்தப் போவதில்லை. வடிகட்டி அல்லது மறுஅளவி-படத்திற்கான வடிகட்டி அல்லது குறியாக்கம்-பயன்பாட்டுக்கு வடிப்பான் எழுதுவதை கற்பனை செய்து பாருங்கள்.

சுருக்கம்

Semalt இது நாம் அடிக்கடி பாதிக்கப்படும் பிரச்சனை அல்ல, பெரிய கோப்புகளை வேலை செய்யும் போது குழப்பம் எளிது. ஒத்தியங்கா பயன்பாடுகளில், மெமரி பயன்பாட்டைப் பற்றி கவனமாக இருக்காத போது முழு சேவையகத்தையும் தரவிறக்கம் செய்வது அவ்வளவு எளிதானது.

இந்த டுடோரியல் சில புதிய யோசனைகளை உங்களுக்கு அறிமுகப்படுத்தியுள்ளது (அல்லது அவற்றைப் பற்றி உங்கள் நினைவைப் புதுப்பித்தல்), இதனால் பெரிய கோப்புகளைப் படிக்கவும் எழுதவும் எப்படி பற்றி மேலும் யோசிக்கலாம். நீரோடைகள் மற்றும் ஜெனரேட்டர்களைப் பற்றி நன்கு தெரிந்துகொண்டு, file_get_contents போன்ற செயல்பாடுகளை பயன்படுத்துவதை நிறுத்திவிட்டால்: ஒரு முழு வகை பிழைகள் எங்கள் பயன்பாடுகளில் இருந்து மறைந்துவிடும். அது ஒரு நல்ல காரியமாகவே தோன்றுகிறது!

March 1, 2018