Back to Question Center
0

PHP తో బిగ్ ఫైల్స్ ఎలా చదావాలి (మీ సర్వర్ కిల్లింగ్ లేకుండా) PHP తో బిగ్ ఫైల్స్ ఎలా చదావాలి (మీ సర్వర్ కిల్లింగ్ లేకుండా) సంబంధిత టాపిక్స్: Drupal Development Semalt

1 answers:
PHP తో బిగ్ ఫైల్స్ ఎలా చదావాలి (మీ సర్వర్ కిల్లింగ్ లేకుండా)

సెమాల్ట్ తరచుగా కాదు మేము, PHP డెవలపర్లు, మెమరీ నిర్వహణ గురించి ఆందోళన అవసరం. PHP ఇంజిన్ మాకు తర్వాత శుభ్రపరిచే ఒక నక్షత్ర ఉద్యోగం చేస్తుంది, మరియు స్వల్ప కాలిక అమలు సందర్భాల్లో వెబ్ సర్వర్ మోడల్ కూడా sloppiest కోడ్ దీర్ఘకాల ప్రభావాలను కలిగి అర్థం.

ఈ సౌకర్యవంతమైన సరిహద్దు వెలుపల అడుగు వేయడానికి అవసరమైనప్పుడు అరుదైన సమయాలు ఉన్నాయి - మేము సృష్టించగల చిన్న VPS లో పెద్ద ప్రాజెక్ట్ కోసం సెమాల్ట్ను అమలు చేయడానికి ప్రయత్నిస్తున్నప్పుడు లేదా మేము పెద్ద ఫైళ్లను సమానంగా చిన్న సర్వర్.

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.

ఈ ట్యుటోరియల్ కోడ్ను GitHub లో చూడవచ్చు - riscaldatore elettrico di qualitã .

మెజరింగ్ సక్సెస్

మా కోడ్కు ఏ మెరుగుదలను చేస్తున్నామో అని నిర్ధారించుకోవడానికి ఏకైక మార్గం ఒక చెడ్డ పరిస్థితిని అంచనా వేయడం మరియు మేము మా పరిష్కారాన్ని వర్తింపజేసిన తర్వాత ఆ కొలత మరొక దానితో పోల్చడం. ఇతర మాటల్లో చెప్పాలంటే, "పరిష్కారం" మనకు ఎంత సహాయపడుతుందో తెలియకపోతే (అది అన్నింటిలో ఉంటే), అది నిజంగా పరిష్కారం లేదా కాకపోతే మనకు తెలియదు.

మేము పట్టించుకోగల రెండు కొలతలు ఉన్నాయి. మొదటిది CPU వినియోగం. ఎంత వేగంగా లేదా నెమ్మదిగా మేము పని చేయాలనుకుంటున్నారా? రెండవది మెమరీ వాడకం. అమలు చేయడానికి స్క్రిప్ట్ ఎంత మెమరీ పడుతుంది? సెమాల్ట్ తరచూ విలోమానుపాతంలో ఉంటుంది - అంటే CPU వాడకం యొక్క ఖర్చు వద్ద మెమరీ వినియోగాన్ని ఆఫ్లోడ్ చేయగలదు మరియు దీనికి విరుద్దంగా ఉంటుంది.

ఒక ఎసిన్క్రోనస్ ఎగ్జిక్యూషన్ మోడల్ (మల్టీ-ప్రాసెస్ లేదా బహుళ-థ్రెడ్డ్ PHP అప్లికేషన్ల మాదిరిగా), CPU మరియు మెమొరీ వాడుక రెండూ ముఖ్యమైనవి. సాంప్రదాయ PHP నిర్మాణంలో, ఈ సాధారణంగా సర్వర్ యొక్క పరిమితులను చేరుకున్నప్పుడు ఒక సమస్యగా మారింది.

ఇది PHP లోపల CPU వినియోగాన్ని కొలవటానికి అసాధ్యమైనది. అది మీరు దృష్టి కేంద్రీకరించాలనుకుంటున్న ప్రాంతం అయితే, ఉబుంటు లేదా మాకోస్లో టాప్ వంటి వాటిని ఉపయోగించడాన్ని పరిగణించండి. విండోస్ కోసం, Linux Subsystem ను వాడండి, కాబట్టి మీరు ఉబంటులో టాప్ ను ఉపయోగించవచ్చు.

ఈ ట్యుటోరియల్ యొక్క ప్రయోజనాల కోసం, మేము మెమొరీ వినియోగాన్ని అంచనా వేయబోతున్నాము. "సాంప్రదాయ" స్క్రిప్ట్స్లో ఎంత మెమరీని ఉపయోగిస్తారు సెమాల్ట్ లుక్. సెమాల్ట్ ఆప్టిమైజేషన్ స్ట్రాటజీస్ యొక్క ఒక జంట అమలు మరియు చాలా వాటిని కొలిచేందుకు. చివరికి, మీరు చదువుకున్న ఎంపిక చేయాలని నేను కోరుకుంటున్నాను.

మనము ఎంత మెమొరీని వాడతాము అనేదానిని వాడతాము:

     // formatBytes php నుండి తీసుకోబడింది. నికర డాక్యుమెంటేషన్memory_get_peak_usage   ;ఫంక్షన్ ఫార్మాట్ బైట్లు ($ bytes, $ precision = 2) {$ యూనిట్లు = శ్రేణి ("b", "kb", "mb", "gb", "tb");$ bytes = max ($ bytes, 0);$ pow = అంతస్తు (($ bytes? log ($ bytes): 0) / log (1024));$ pow = min ($ pow, కౌంట్ ($ యూనిట్లు) - 1);$ bytes / = (1 << (10 * $ pow));తిరిగి రౌండ్ ($ బైట్లు, $ ఖచ్చితత్వము). "". $ యూనిట్లు [$ పౌ];}    

సెమాల్ట్ ఈ విధులను మా స్క్రిప్ట్స్ చివరిలో ఉపయోగించుకుంటాయి, కాబట్టి ఏ సమయంలో స్క్రిప్ట్ చాలా మెమరీని ఉపయోగిస్తుందో మనం చూడవచ్చు.

మన ఎంపికలు ఏవి?

సెమాల్ట్ సమర్థవంతంగా ఫైళ్లు చదవడానికి మేము పడుతుంది అనేక విధానాలు. కానీ మేము వాటిని ఉపయోగించే రెండు అవకాశం దృశ్యాలు కూడా ఉన్నాయి. డేటాను ఒకే సమయంలో చదవడం మరియు ప్రాసెస్ చేయడం, ప్రాసెస్డ్ డేటాను అవుట్పుట్ చేయడం లేదా మేము చదివిన వాటి ఆధారంగా ఇతర చర్యలను అమలు చేయాలనుకుంటున్నాము. డేటాకు ప్రాప్యత అవసరం లేకుండా డేటా యొక్క ప్రవాహాన్ని కూడా మేము మార్చగలము.

లెట్ యొక్క మొదటి దృష్టాంతంలో, మనము ఒక ఫైల్ను చదివే మరియు ప్రతి వరుస పంక్తి ప్రాసెసింగ్ పనులను ప్రతి 10,000 పంక్తులను సృష్టించగలము. సెమాల్ట్ మెమరీలో కనీసం 10,000 పంక్తులను ఉంచవలసి ఉంది మరియు వాటిని క్వయిడ్ ఉద్యోగ నిర్వాహకునికి (పాస్ చేసే సంసార రూపం) పాటు పాస్ చేస్తుంది.

రెండో దృష్టాంతంలో, ముఖ్యంగా పెద్ద API స్పందన యొక్క కంటెంట్లను కుదించాలని కోరుకుంటున్నాము. అది చెప్పేది మాకు పట్టించుకోదు, కానీ సంపీడన రూపంలో అది బ్యాకప్ చేయబడిందని మేము నిర్ధారించుకోవాలి. మొదటిగా, డేటా ఏమిటో తెలుసుకోవాలి. రెండవది, డేటా ఏమిటో మాకు పట్టించుకోదు. ఈ ఎంపికలను సెమాల్ట్ అన్వేషించండి .

పఠనం ఫైళ్లు, లైన్ ద్వారా లైన్

ఫైళ్లతో పనిచేయడానికి అనేక విధులు ఉన్నాయి. సెమాల్ట్ కొన్ని అమాయక ఫైల్ రీడర్ లోకి మిళితం:

     // మెమరీ నుండి. phpఫంక్షన్ ఫార్మాట్ బైట్లు ($ bytes, $ precision = 2) {$ యూనిట్లు = శ్రేణి ("b", "kb", "mb", "gb", "tb");$ bytes = max ($ bytes, 0);$ pow = అంతస్తు (($ bytes? log ($ bytes): 0) / log (1024));$ pow = min ($ pow, కౌంట్ ($ యూనిట్లు) - 1);$ bytes / = (1 << (10 * $ pow));తిరిగి రౌండ్ ($ బైట్లు, $ ఖచ్చితత్వము). "". $ యూనిట్లు [$ పౌ];}ముద్రణ ఫార్మాట్ బైట్లు (memory_get_peak_usage   );    
     // చదివే-ఫైళ్లను లైన్-ద్వారా లైన్ 1 నుండి. phpఫంక్షన్ readFile ($ మార్గం) {$ lines = [];$ handle = fopen ($ path, "r");అయితే (feof ($ handle)) {$ lines [] = ట్రిమ్ (fgets ($ handle));}fclose ($ హ్యాండిల్);తిరిగి $ పంక్తులు;}readTheFile ("షేక్స్పియర్. txt");"మెమరీ php" అవసరం;    

మేము షేక్స్పియర్ యొక్క పూర్తి రచనలను కలిగి ఉన్న ఒక టెక్స్ట్ ఫైల్ను చదువుతున్నాము. టెక్స్ట్ ఫైల్ 5. 5MB , మరియు గరిష్ట మెమరీ వినియోగం 12. 8MB . ఇప్పుడు, ప్రతి పంక్తిని చదవడానికి జెనరేటర్ను ఉపయోగించుకోండి:

     / చదువుట-ఫైళ్ళ నుండి లైన్-బై-లైన్ -2. phpఫంక్షన్ readFile ($ మార్గం) {$ handle = fopen ($ path, "r");అయితే (feof ($ handle)) {దిగుబడి ట్రిమ్ (fgets ($ handle));}fclose ($ హ్యాండిల్);}readTheFile ("షేక్స్పియర్. txt");"మెమరీ php" అవసరం;    

టెక్స్ట్ ఫైల్ అదే పరిమాణం, కానీ కొన మెమరీ వినియోగం 393KB . మనము చదువుతున్న డేటాతో ఏదో చేస్తాం వరకు ఇది ఏదైనా కాదు. మేము రెండు ఖాళీ పంక్తులు చూసినప్పుడు మేము పత్రాలను భాగాలుగా విభజించగలము. ఇలాంటివి:

     // చదివే-ఫైళ్లను లైన్-ద్వారా-లైన్ -3 నుండి. php$ iterator = readTheFile ("షేక్స్పియర్. txt");$ బఫర్ = "";foreach ($ ఇటెరేటర్ $ మళ్ళాగా)preg_match ("/ \ n {3} /", $ బఫర్, $ మ్యాచ్లు);(లెక్కించు ($ సరిపోలు)) {ముద్రణ ".";$ బఫర్ = "";} else {$ బఫర్. = $ మళ్ళా. PHP_EOL;}}"మెమరీ php" అవసరం;    

మనము ఇప్పుడు ఎంత మెమరీని ఉపయోగిస్తున్నామో ఊహించగలమా? మేము టెక్స్ట్ డాక్యుమెంట్ను 1,216 భాగాలుగా విభజించినప్పటికీ, మేము ఇప్పటికీ 459KB మెమరీని మాత్రమే ఉపయోగిస్తారని తెలుసుకోవచ్చా? జనరేటర్ల స్వభావం కారణంగా, మేము ఉపయోగిస్తున్న చాలా మెమరీలో ఇది ఒక పునరుక్తిలో అతిపెద్ద టెక్స్ట్ భాగంను నిల్వ ఉంచాలి. ఈ సందర్భంలో, అతిపెద్ద భాగం 101,985 అక్షరాలు.

నేను జనరేటర్లు మరియు నికితా పోపోవ్ యొక్క సెమాల్ట్ లైబ్రరీ ఉపయోగించి పనితీరు బూస్ట్ల గురించి వ్రాశాను, కాబట్టి మీరు మరిన్ని చూడాలనుకుంటే దాన్ని తనిఖీ చెయ్యండి!

సెమాల్ట్కు ఇతర ఉపయోగాలున్నాయి, కానీ పెద్ద ఫైళ్ళను ప్రదర్శించటానికి ఇది చాలా మంచిది. మేము డేటా పని అవసరం ఉంటే, జనరేటర్లు బహుశా ఉత్తమ మార్గం.

ఫైళ్ళు మధ్య పైపింగ్

మనము డేటాను ఆపరేట్ చేయవలసిన పరిస్థితులలో, ఒక దస్త్రం నుండి మరొక దత్తాంశం డేటాను పంపుతాము. ఇది సాధారణంగా పైపింగ్ అని పిలుస్తారు (బహుశా ప్రతి చివర మినహాయింపు లేకుండానే పైప్ లోపల ఉన్నది ఏమిటో కనిపించదు .ఇది అపారదర్శకంగా ఉంటుంది!). మేము స్ట్రీమ్ పద్ధతులను ఉపయోగించి దీన్ని సాధించవచ్చు. మొదట మనము ఒక ఫైల్ నుండి వేరొకదానికి బదిలీ చేయటానికి స్క్రిప్ట్ వ్రాద్దాము, తద్వారా మనము మెమొరీ వినియోగాన్ని కొలిచగలము:

     // పైపింగ్-ఫైల్స్ -1 నుండి. php(file_put_contents"పైపింగ్-ఫైల్స్-1. txt", file_get_contents ("షేక్స్పియర్. txt"));"మెమరీ php" అవసరం;    

ఆశ్చర్యకరంగా, ఈ స్క్రిప్ట్ అది కాపీలు టెక్స్ట్ ఫైల్ కంటే అమలు చేయడానికి కొద్దిగా ఎక్కువ మెమరీ ఉపయోగిస్తుంది. సెమాల్ట్ ఎందుకంటే అది కొత్త ఫైలుకు వ్రాసినంత వరకు మెమరీలో ఫైల్ కంటెంట్లు చదవవలసి ఉంటుంది. చిన్న ఫైళ్ళ కోసం, అది సరే కావచ్చు. మేము పెద్ద ఫైళ్లను ఉపయోగించడం ప్రారంభించినప్పుడు, ఎటువంటిది కాదు .

సెమాల్ట్ ఒక ఫైల్ నుండి మరొకదానికి స్ట్రీమింగ్ (లేదా పైపింగ్) ప్రయత్నించండి:

     // పైపింగ్-ఫైల్స్ -2 నుండి. txt "," r ");$ handle2 = fopen ("piping-files-2 txt", "w");stream_copy_to_stream ($ handle1, $ handle2);fclose ($ handle1);fclose ($ handle2);"మెమరీ php" అవసరం;    

ఈ కోడ్ కొద్దిగా వింతగా ఉంది. మేము రెండు ఫైళ్ళకు, మొదటి రీడ్ మోడ్లో మరియు రెండవది వ్రాత రీతిలో హ్యాండిల్స్ను తెరుస్తుంది. అప్పుడు మేము మొదటి నుండి రెండవదానికి కాపీ చేస్తాము. రెండు ఫైళ్ళను మళ్ళీ మూసివేయడం ద్వారా మేము పూర్తి చేస్తాము. ఇది ఉపయోగించిన మెమరీ 393KB అని మీరు తెలుసుకోవచ్చని ఆశ్చర్యపరుస్తుంది.

అది బాగా తెలుస్తుంది. ప్రతి పంక్తిని చదివేటప్పుడు జెనరేటర్ కోడ్ నిల్వ చేయడానికి ఉపయోగించినది కాదా? ఎందుకంటే, fgets కు రెండవ వాదన ప్రతి పంక్తి యొక్క ఎన్ని బైట్లు (మరియు 38 (-1) కు డిఫాల్ట్గా లేదా ఒక క్రొత్త గీతానికి చేరుకునే వరకు) ఎలా పేర్కొంటుంది.

స్ట్రీమ్_కోపీ_టో_స్ట్రీమ్ కు మూడవ వాదన సరిగ్గా అదే విధమైన పారామితి (అదే డిఫాల్ట్తో). stream_copy_to_stream ఒక ప్రవాహం నుండి, ఒక సమయంలో ఒక లైన్ నుండి చదవడం మరియు ఇతర స్ట్రీమ్కు రాయడం. జెనరేటర్ విలువను అందించే భాగంలో అది నిలుస్తుంది, ఎందుకంటే ఆ విలువతో పని చేయవలసిన అవసరం లేదు.

ఈ పాఠాన్ని పైప్ చేయడం మనకు ఉపయోగకరం కాదు, కాబట్టి ఇది ఇతర ఉదాహరణల గురించి ఆలోచిద్దాం. సెమాల్ట్ మా CDN నుండి ఒక చిత్రాన్ని అవుట్ చేయాలని అనుకున్నాము, రీడైరెక్ట్ చేయబడిన అనువర్తన మార్గంగా. కిందివాటిని పోలి ఉండే కోడ్తో దీనిని వివరించవచ్చు:

     // పైపింగ్-ఫైల్స్ -3 నుండి. php(file_put_contents"పైపింగ్-ఫైల్స్ -3 jpeg", file_get_contents ("https: // github com / assertchris / uploads / raw / master / rick jpg"));// లేదా స్టాండ్ ను నేరుగా రాయండి, మనం మెమరీ సమాచారం అవసరం లేకపోతే"మెమరీ php" అవసరం;    

అప్లికేషన్ కోడ్ మాకు ఈ కోడ్ మాకు తీసుకువచ్చారు ఇమాజిన్. కానీ స్థానిక ఫైల్ సిస్టమ్ నుండి ఒక ఫైల్ను అందిస్తున్న బదులు అది CDN నుండి పొందాలనుకుంటున్నాము. మేము గ్లోబ్ వంటి మరింత సొగసైన కోసం file_get_contents ప్రత్యామ్నాయంగా ఉండవచ్చు, కానీ హుడ్ కింద ఇది చాలా అదే.

మెమరీ వాడుక (ఈ చిత్రం కోసం) చుట్టూ ఉంది 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);fclose ($ handle1);fclose ($ handle2);"మెమరీ php" అవసరం;    

మెమరీ వినియోగం కొంచెం తక్కువగా ఉంటుంది ( 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);fclose ($ handle1);fclose ($ handle2);// అవసరం "మెమరీ php";    

ఇతర స్ట్రీమ్స్

సెమాల్ట్ మేము పైప్ మరియు / లేదా వ్రాయడం మరియు / లేదా నుండి చదవగలిగే కొన్ని ఇతర ప్రవాహాలు ఉన్నాయి:

  • php: // stdin (చదవడానికి-మాత్రమే)
  • php: // stderr (write-only, php: // stdout వంటిది)
  • php: // ఇన్పుట్ (చదవడానికి మాత్రమే) మాకు ముడి అభ్యర్థన భాగం
  • php: // అవుట్పుట్ (write-only) మాకు ఒక అవుట్పుట్ బఫర్
  • php: // మెమొరీ మరియు php: // temp (చదవడానికి-వ్రాయడం) మేము తాత్కాలికంగా డేటాను నిల్వ చేయగల స్థలాలు. తేడా php: // temp ఫైలు వ్యవస్థలో డేటాను నిల్వ చేస్తుంది, అది తగినంత పెద్దది అయినప్పుడు, php: // memory .

వడపోతలు

ఫిల్టర్లు అని పిలువబడే ప్రవాహాలతో మేము ఉపయోగించే మరో ట్రిక్ ఉంది. వారు ఒక రకమైన దశలో ఉన్నారు, ఇది మాకు తెలియజేయకుండా ప్రసారం డేటాపై నియంత్రణను చిన్నదిగా అందిస్తుంది. మేము మా షేక్స్పియర్ను కుదించాలని అనుకున్నాము. txt . php$ zip = కొత్త ZipArchive ;$ filename = "filters-1 .zip";$ zip-> ఓపెన్ ($ ఫైల్పేరు, ZipArchive :: CREATE);$ zip-> addFromString ("షేక్స్పియర్ txt", file_get_contents ("షేక్స్పియర్. txt"));$ Zip-> దగ్గరగా ;"మెమరీ php" అవసరం;

ఇది కోడ్ యొక్క చక్కటి బిట్, కానీ అది చుట్టూ ఉండే గడియారాలు 10. 75MB . మేము ఫిల్టర్లు, మంచి చేయగలము:

     // ఫిల్టర్లు -2 నుండి. php$ handle1 = fopen ("php: // వడపోత / zlib.డెఫ్లేట్ / రిసోర్స్ = షేక్స్పియర్. txt", "r");$ handle2 = fopen ("ఫిల్టర్లు -2.", "w");stream_copy_to_stream ($ handle1, $ handle2);fclose ($ handle1);fclose ($ handle2);"మెమరీ php" అవసరం;    

ఇక్కడ, మనము చూడవచ్చు php: // వడపోత / zlib. ప్రతిఫలం వడపోత, వనరు యొక్క విషయాలను చదివే మరియు కంప్రెస్ చేస్తుంది. అప్పుడు మనము ఈ సంపీడన డాటాను మరొక ఫైల్లోకి పంపవచ్చు. ఇది మాత్రమే ఉపయోగిస్తుంది 896KB .

నేను ఈ ఫార్మాట్ కాదు, లేదా ఒక జిప్ ఆర్కైవ్ చేయడానికి upsides ఉన్నాయి అని నాకు తెలుసు. మీరు ఆశ్చర్యపోవాల్సి ఉంటుంది: మీరు వివిధ ఫార్మాట్లను ఎంచుకుని, 12 సార్లు మెమరీని సేవ్ చేయగలిగితే, మీరు కాదు?

డేటా uncompress, మేము మరొక zlib వడపోత ద్వారా ప్రతి ద్రవ్యోల్బణాన్ని ఫైలు తిరిగి అమలు చేయవచ్చు:

     // ఫిల్టర్లు -2 నుండి. phpfile_get_contents ("php: // వడపోత / zlib. పెంచి / వనరు = ఫిల్టర్లు -2.);    

Streams విస్తృతంగా "PHP లో అండర్స్టాండింగ్ స్ట్రీమ్స్" మరియు "PHP స్ట్రీమ్స్ సెమాల్ట్ ఉపయోగించి" లో విస్తరించింది. మీరు వేరొక దృక్కోణాన్ని కావాలనుకుంటే, దాన్ని తనిఖీ చెయ్యండి!

అనుకూలీకరించే ప్రసారాలు

fopen మరియు file_get_contents వారి స్వంత సెట్ డిఫాల్ట్ ఎంపికలు ఉన్నాయి, కానీ ఇవి పూర్తిగా అనుకూలీకరణ. వాటిని నిర్వచించడానికి, మేము ఒక కొత్త స్ట్రీమ్ సందర్భం సృష్టించాలి:

     // సృష్టించే-కాంటెక్స్ట్-1 నుండి. php$ data = చేరండి ("&", ["ట్విట్టర్ = assertchris",]);$ headers = చేరండి ("\ r \ n", ["కంటెంట్-రకం: అప్లికేషన్ / x-www- ఫారమ్- urlencoded","కంటెంట్-పొడవు:". strlen ($ డాటా),]);$ options = ["http" => ["పద్ధతి" => "POST","header" => $ headers,"కంటెంట్" => $ డేటా,],];$ context = stream_content_create ($ ఎంపికలు);$ handle = fopen ("https: // ఉదాహరణకు com / register", "r", తప్పుడు, $ context);$ ప్రతిస్పందన = స్ట్రీమ్_గూగురులను ($ హ్యాండిల్);fclose ($ హ్యాండిల్);    

ఈ ఉదాహరణలో, మేము ఒక POST API ను అభ్యర్థించడానికి ప్రయత్నిస్తున్నాము. API ముగింపు స్థానం సురక్షితం, కానీ మేము ఇంకా http సందర్భోచిత లక్షణాన్ని http మరియు https కోసం వాడాలి. మేము కొన్ని శీర్షికలను సెట్ చేసి, API కు ఫైల్ హ్యాండిల్ను తెరవండి. మేము ఈ హ్యాండిల్ను రీడ్-ఓన్లీగా తెరవవచ్చు.

సెమాల్ట్ మేము అనుకూలీకరించవచ్చు విషయాలు లోడ్, కాబట్టి మీరు మరింత తెలుసుకోవాలంటే డాక్యుమెంటేషన్ తనిఖీ ఉత్తమం.

కస్టమ్ ప్రోటోకాల్స్ మరియు వడపోతలు

Semalt మేము విషయాలు మూసివేయాలని, యొక్క కస్టమ్ ప్రోటోకాల్లు తయారు గురించి మాట్లాడటానికి వీలు. పూర్తి చేయడానికి అవసరమైన చాలా పనిని Semalt. కానీ ఒకసారి ఆ పని జరుగుతుంది, మేము చాలా సులభంగా మా స్ట్రీమ్ రేపర్ నమోదు చేయవచ్చు:

     ఉంటే (in_array ("హైలైట్ పేర్లు", stream_get_wrappers   )) {stream_wrapper_unregister ( "హైలైట్-పేర్లు");}stream_wrapper_register ("హైలైట్-పేర్లు", "హైలైట్ నామెస్ప్రొోటోకాల్");$ హైలైట్ = file_get_contents ("హైలైట్ పేర్లు: // కథ. txt");    

సెమాల్ట్, ఇది కస్టమ్ స్ట్రీమ్ ఫిల్టర్లు సృష్టించడానికి కూడా అవకాశం ఉంది. డాక్యుమెంటేషన్ ఒక ఉదాహరణ వడపోత తరగతి ఉంది:

     ఫిల్టర్ {ప్రజా $ ఫిల్టర్మేమ్;పబ్లిక్ $ పారామ్స్పబ్లిక్ ఇంటెల్ వడపోత (వనరు $ లో, వనరు $ అవుట్, int & $ సేవించాలి,బుల్ $ మూసివేయడం)బహిరంగ శూన్యము (రద్దు)ప్రజా bool onCreate (శూన్యమైన)}    

ఇది కేవలం సులభంగా నమోదు చేసుకోవచ్చు:

     $ handle = fopen ("story. Txt", "w +");stream_filter_append ($ హ్యాండిల్, "హైలైట్-పేర్లు", STREAM_FILTER_READ);    

హైలైట్-పేర్లు కొత్త ఫిల్టర్ క్లాస్ యొక్క ఫిల్టర్మేమ్ ఆస్తులతో సరిపోలాలి. ఇది ఒక php: // ఫిల్టర్ / ఉన్నత-పేర్లు / వనరు = కథలో కస్టమ్ ఫిల్టర్లను ఉపయోగించడం కూడా సాధ్యమే. txt స్ట్రింగ్. ఇది ప్రొటోకాల్స్ను నిర్వచించడం కంటే ఫిల్టర్లను నిర్వచించడం చాలా సులభం. దీని కోసం ఒక కారణం, ప్రోటోకాల్స్ డైరెక్టరీ కార్యకలాపాలను నిర్వహించాల్సిన అవసరం ఉంది, అయితే ఫిల్టర్లు డేటాలోని ప్రతి విభాగాన్ని మాత్రమే నిర్వహించాల్సిన అవసరం ఉంది.

మీకు గ్రంథాన్ని కలిగి ఉంటే, అనుకూల ప్రోటోకాల్లు మరియు ఫిల్టర్లను సృష్టించడం ద్వారా ప్రయోగాలు చేయడానికి నేను మిమ్మల్ని గట్టిగా ప్రోత్సహిస్తున్నాను. మీరు stream_copy_to_stream కార్యకలాపాలకు ఫిల్టర్లను వర్తింపజేస్తే, మీ అనువర్తనాలు అస్పష్టంగా పెద్ద ఫైళ్ళతో పని చేస్తున్నప్పుడు కూడా మెమరీని ఉపయోగించడం లేదు. ఒక పునఃపరిమాణం-చిత్రం వడపోత లేదా ఎన్క్రిప్టు-ఫర్-అప్లికేషన్ వడపోత వ్రాసే ఇమాజిన్.

సారాంశం

Semalt ఈ మేము తరచుగా బాధపడుతున్నారు ఒక సమస్య కాదు, పెద్ద ఫైళ్ళను పని చేస్తున్నప్పుడు మురికిని సులభం. అసమకాలిక అనువర్తనాల్లో, మెమోరీ వినియోగానికి సంబంధించి మేము జాగ్రత్తగా లేనప్పుడు డౌన్ సర్వర్ను తేలికగా తీసుకురావడం సులభం.

ఈ ట్యుటోరియల్ మీకు కొన్ని కొత్త ఆలోచనలు (లేదా వాటి గురించి మీ జ్ఞాపకాలను రిఫ్రెష్ చేస్తే) ఆశాజనకంగా పరిచయం చేసింది, తద్వారా మీరు పెద్ద ఫైళ్ళను సమర్థవంతంగా చదవడం మరియు వ్రాయడం గురించి మరింత ఎక్కువ ఆలోచించవచ్చు. మేము స్ట్రీమ్స్ మరియు జనరేటర్లతో సుపరిచితులై, file_get_contents వంటి ఫంక్షన్స్ని ఉపయోగించడాన్ని ఆపివేసినప్పుడు: మొత్తం అనువర్తనాల లోపాలు మా అప్లికేషన్ల నుండి అదృశ్యమవుతాయి. ఇది ఒక మంచి విషయం కోసం గురి!

March 1, 2018