PHP ప్రాక్టీస్: స్ట్రింగ్ పోలిక

PHP మంచి సమాచారం హ్యాండ్లింగ్ పై దృష్టి. భాష యొక్క సింటాక్స్ పోలిక విధులు, స్ట్రింగ్ ప్రాసెసింగ్, పోలిక ఆపరేటర్ల పూర్తిగా ఫంక్షనల్ సెట్ సూచించబడుతుంది.

ఏ అల్గోరిథం - ఎంపికలు మరియు చర్యల క్రమం. కానీ మీరు ఒక ఎంపిక చేయడానికి ముందు, మీరు ఏదో తో పోల్చడం ఏదో అవసరం. లైన్ - అత్యంత తోనూ సమర్థవంతమైన మరియు ఆచరణాత్మక అల్గోరిథం నియంత్రణ విధానం. లైన్ - డేటా ప్రదర్శన యొక్క రూపాంతరం. ఒక డేటా - ఏదైనా అల్గోరిథం యొక్క "రక్షణ" యొక్క ప్రధాన అంశంగా ఉంది.

సాధారణ తర్కం "పోలిక చర్య"

సాధారణంగా, డైనమిక్ టైపింగ్ నాలుక వంటి PHP పోలిక లైన్ డేటా ఏ వ్యత్యాసం, చేస్తుంది మరియు సంఖ్య చాలా భిన్నంగా లేదు. సంఖ్య - అది మాత్రమే సంఖ్యలు, పాయింట్ కలిగి మరియు ఏ రూపం (గణిత శాస్త్ర సంజ్ఞామానం) సంఖ్యలకు ప్రాతినిధ్యం వహిస్తున్నాయి ఉపయోగించరు అని ఒకే పాత్ర లేదు ఉన్నప్పుడు, కూడా ఒక స్ట్రింగ్.

kontenkatsii సంఖ్య స్వయంచాలకంగా లైన్ విలీనమైంది ఉంటే, ఎలాంటి ప్రశ్నలు అడిగారు మరియు రహస్య లోపాలు, కూడా gettype () ఫంక్షన్ 'పూర్ణాంక' లేదా 'డబుల్' ఇస్తుంది.

అయితే, is_int () మరియు is_numeric ఉపయోగించి మధ్య తేడా ఉంది (). మొదటి, సత్యం ఇస్తుంది పరామితి, రెండవ, ఒక పూర్ణ సంఖ్య పరిచినప్పుడు మాత్రమే ఏదైనా సంఖ్య లేదా సంఖ్యా స్ట్రింగ్ (వేరియబుల్ రకం 'తీగ' ఉంది, కానీ అన్ని అందించిన గణిత శాస్త్ర సంజ్ఞామానం వుంటారు) ఉన్నప్పుడు.

ఒక PHP స్ట్రింగ్ పోలిక ఆపరేటర్స్ (! '==' '===' ... '=') అనేక ఆశ్చర్యకరమైన ప్రస్తుత ఎలా ఒక మంచి ఉదాహరణ - ఈ ఒక సాధారణ ఉదాహరణ. వేరియబుల్స్ వారు ఎల్లప్పుడూ సంఖ్యలు లేని, వారి రకం మార్చవచ్చు, కానీ దాదాపు ఎల్లప్పుడూ వారు లైన్ దారితీస్తుంది. విపత్కర పరిస్థితులలో - ఇది ఒక ఖాళీ స్ట్రింగ్ ఉంటుంది.

పైన ఆధారంగా, ఒక PHP స్ట్రింగ్ పోలిక ఫంక్షన్ చాలా పేరుగాంచినది. వేటి ఎంచుకోవడానికి, డెవలపర్ నిర్ణయించే. సాధారణ వ్యక్తీకరణలను వరకు అందుబాటులో ఎంపికలు బోలెడంత.

అందుబాటులో ఫంక్షనల్ సరిహద్దులను

రెండు వరుసలలో PHP-పోలిక మంచిది "ఏమి" ఫంక్షన్ strpos () - చౌకైన, విశ్వాసకులు వాస్తవిక ఎంపిక. ఉంటే ఫలితంగా ఫంక్షన్ సంఖ్య, అప్పుడు స్పష్టంగా ఒక స్ట్రింగ్ మరొక లేదా మరొక భాగానికి సమానం.

తీవ్రంగా సరసన, కానీ కూడా ఖచ్చితంగా కుడి విధానం - సాధారణ వ్యక్తీకరణల వినియోగం.

ఫంక్షన్ $ cResult = scCheckFileName ($ cStr) 'నిజమైన' ఇస్తుంది ఉంటే, అప్పుడు లైన్ ఫైలు vordovsky యొక్క పేరు. అక్షరాలు, అంకెలు మరియు అక్షరాలు '_', '-': అతను మరియు విస్తరణకు '.docx' మాత్రమే ఒక ఎంపికను పేరిట ఏ అక్షరాలు ఉంటుంది.

ఫంక్షన్ సులభంగా ఇతర రకాలైన మార్చవచ్చును: $ cPtr = '/^([a-zA-Z...0-9\-\_]{4,239})\.(html|js|css|png|jpg | docx | టిఎక్స్ టి) {1} $ / u '. ఈ వేరియంట్ html కోసం పరిధి స్కాన్ లైన్కు డౌన్లోడ్ (ఉదా: PHP స్ట్రింగ్ పోలిక "ఇన్పుట్ లోపం యొక్క అవకాశం, ఒక సర్వర్ ఫైళ్లను అప్లోడ్" వర్తించబడుతుంది) విస్తరించి, JS, CSS, ...

తీవ్రతలు - strpos () మరియు preg_match () ఉపయోగించి. వారు నేరుగా పోలిక కాలం సమస్యకు సంబంధం లేదు. కానీ అల్గోరిథం యొక్క ప్రశ్న - శైలి యొక్క ఒక కలయికను ఉపయోగించి ఒక పదార్థం, అన్ని అవకాశాలు ఉపయోగం ఒక నమ్మకమైన మరియు సరైన ఫలితాన్ని సాధించడానికి ఉంది.

ఫంక్షనల్ PHP: స్ట్రింగ్ పోలిక

ఆర్సెనల్ భాష పోలిస్తే తీగలను - ఒక స్వచ్ఛమైన, మాత్రమే పోలిక ఫంక్షన్, కానీ కూడా నేరుగా ఒక శోధన లేదా ప్రత్యామ్నాయంగా కలయిక. ఎల్లప్పుడూ రెండో తప్పనిసరిగా ఏ వరుస లో మార్పు దారి లేదు నుండి, పోలిక రోజే తప్పక పని లేదు. తరచుగా మీరు ఒకటి లేదా అల్గోరిథం యొక్క ఇతర శాఖ ఎంచుకోవడానికి కలిగి.

సాధారణ వేరియంట్ PHP: స్ట్రింగ్ పోలిక ఫంక్షన్ పూర్ణాంకానికి strcmp అమలు (S1, S2).

పనితీరు ఫలితంగా:

• 0 - లైన్ సమానం;
• -1 - మొదటి స్ట్రింగ్ రెండవ కంటే తక్కువ;
• 1 - రెండవ వరుసలో కంటే మొదటి మరింత.

ఆచరణలో, ఈ రెండవ మొదటి వరుస, PHP ఫంక్షన్ (పోలిక వరుసలు) నిర్ణయిస్తుంది నుండి ఆ భాగంలో అర్థం. strpos () మరింత పరిమిత వెర్షన్ ప్రవేశ స్థానం తెలుసు రెండో సందర్భంలో అది సాధ్యం ఎందుకంటే.

strcmp () ఫంక్షన్ - సున్నితమైన. () మీరు స్ట్రింగ్ స్పందించని పోల్చడానికి కావాలా, PHP దాని strcasecmp అందిస్తుంది. వాక్యనిర్మాణం పోలి ఉంటుంది.

ఆచరణలో తరచుగా భాగాన్ని మాత్రమే మొత్తం మార్గం కాదు పని అవసరం, కానీ. విధులను ఈ సెట్ కోసం PHP (స్ట్రింగ్ పోలిక) చేర్చారు strncmp (S1, S2, N). మూడవ పారామీటర్ మాత్రమే n-బైట్లు పోలిక నిర్వహించడానికి నిర్దేశిస్తుంది. ఫలితంగా ఇదే strcmp () ఉంది.

వ్యూహాలను, స్ట్రింగ్స్ మరియు పోల్చడం

ఈ దాదాపు ఎల్లప్పుడూ తీగలను సూచించబడతాయి. మేము శ్రేణుల, వస్తువులు, లేదా డేటా నిర్మాణాలు పరిగణలోకి ఉంటే, అది ఒక సాధారణ స్ట్రింగ్ నిర్మాణాలు కాంబినేషన్ కేవలం వివిధ రకాలు వార్తలు.

స్ట్రింగ్ శ్రేణుల మరియు వరుసలు ఒక పరిపూరకరమైన పద్ధతిలో సమకూర్చుకోవచ్చు. ఉదాహరణకు ఒక స్ట్రింగ్ ఫంక్షన్ లోపలనే పగిలిపోవు విడదీస్తుంది శ్రేణి (శ్రేణి, చిహ్నం) ది ట్రాన్స్ఫార్మేషన్: $ margins1 = లోపలనే పగిలిపోవు ( ',' $ శైలి> getInnerMargin ()); ... అల్గోరిథం / వినియోగదారు ...; $ Margins2 = లోపలనే పగిలిపోవు ( ',' $ శైలి> getInnerMargin ()) మీరు స్ట్రింగ్ స్థానం వస్తువు స్థానం అన్ని విలీనం అనుమతిస్తుంది.

అప్పుడు మీరు PHP స్ట్రింగ్ పోలిక నిర్వహించడానికి, మరియు ఒక సమయంలో: $ తనిఖీ = strcmp ($ margins1, $ margins2) మరియు నిర్ధారించుకోండి అల్గోరిథం లేదా ఏదో మార్చబడింది (లేదా) యూజర్కు. మీరు సాధారణ విధంగా ఒక పోలిక నిర్వహించడానికి ఉంటే, మీరు, అర్రే మూలకాలు క్రమం ఉంటుంది. ఇది సమయం పడుతుంది మరియు మరింత క్లిష్టంగా ఉంటుంది.

వస్తువులు మరియు లైన్

మరింత అద్భుతమైన ఉపయోగం PHP (స్ట్రింగ్ పోలికలు) ఆబ్జెక్ట్ ఓరియంటెడ్ ఆలోచనలు ద్వారా అమలు చేయవచ్చు.

సౌకర్యాలు ఆధునిక ఆలోచన వారు లక్షణాలు మరియు పద్ధతులు ఉందని సూచించింది. మాజీ సాధారణంగా సంఖ్యలు, తీగలను, శ్రేణుల, మరియు ఇతర వస్తువులను ద్వారా సూచించబడతాయి. రెండో ఎక్కువగా ఇవి ఉంటాయి రికార్డింగ్ పద్ధతులు (చాలు) పునరుద్ధరణ లైన్ లో మరియు లైన్ నుండి (అవుతారు).

శ్రేణుల కాకుండా, వస్తువు వారి సొంత లక్షణాలతో పని చేస్తుంది మరియు ఇతర వస్తువులతో సంకర్షణ. ఆబ్జెక్ట్ దీనిలో దాని లక్షణాలు మొత్తంగా కార్యక్రమం అల్గోరిథం కోసం నిజ విలువ యొక్క ఉన్నాయి "సమర్ధవంతం".

ఈ క్షణం ఒక ఆధారం మరియు ఒక స్ట్రింగ్ మాత్రమే అవసరమైన సమాచారాన్ని రికార్డ్ చేసినప్పుడు రికార్డ్ చేయడానికి అవకాశం అందిస్తుంది, మరియు లైన్ పునరుద్ధరించడంలో కావలసిన రాష్ట్రంలోని అన్ని పని లక్షణాలు పునరుద్ధరించడానికి. సాధారణంగా, ఏ వస్తువు అక్కడ గణనీయమైన సమాచారం మరియు పని (సమయం). ఈ ఆలోచన అమలు మీరు మాత్రమే కాదు జ్ఞాపకశక్తి, డిస్క్ స్పేస్, డేటాబేస్ రికార్డు సేవ్ అనుమతిస్తుంది, కానీ కూడా అది పంక్తులు సరళమైన మరియు మరింత కచ్చితమైన మార్గంగా పోల్చడానికి అవకాశం చేస్తుంది.

సింటాక్స్ మరియు సెమాంటిక్స్

PHP డైనమిక్ అభివృద్ధి, మరియు దాని కార్యాచరణను రెండు తీగలను పోల్చడం నిబంధనలు మరియు నిరంతరం వారి చికిత్స పరంగా అభివృద్ధి. అయితే, ఏమీ సెమాంటిక్స్ ప్రాంతంలో గురుత్వ కేంద్రాన్ని తరలించడానికి ఒక డెవలపర్ నిరోధిస్తుంది.

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