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

ஒற்றை மேற்கோள்கள்

ஒரு சரத்தை வரையறுப்பதற்கான எளிய வழி, ஒற்றை மேற்கோள்களில் உரையை இணைப்பதாகும்.

உரையில் ஒரு மேற்கோளைப் பயன்படுத்த வேண்டுமானால், அதை முன்னோக்கி சாய்வு (\) மூலம் தப்பிக்க வேண்டும்.

ஒற்றை மேற்கோள்களுக்குள் எஸ்கேப் காட்சிகள் வேலை செய்யாது.

ஒற்றை மேற்கோள்களைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டுகள்:

இரட்டை மேற்கோள்கள்

இரட்டை மேற்கோள்களுடன் உரையை முன்னிலைப்படுத்தினால், ஒற்றை மேற்கோள்களைப் போலவே சரமும் வரையறுக்கப்படும். ஆனால் நிச்சயமாக மேற்கோள்களுக்கு இடையில் வேறுபாடுகள் உள்ளன.

மேற்கோள்களிலிருந்து தப்பிக்கும் நிலைமை ஒற்றை மேற்கோள்களைப் போலவே உள்ளது.

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

மிக முக்கியமான வேறுபாடு என்னவென்றால், இரட்டை மேற்கோள்கள் மாறிகளைக் கையாளுகின்றன.

இரட்டை மேற்கோள்களைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டுகள்:

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

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

கணக்கீடுகள்

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

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

PHP இல் ஒற்றை மேற்கோள்கள் (அப்போஸ்ட்ரோபிஸ்).

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

// சரியான எதிரொலி "வாழ்க்கை எப்படி இருக்கிறது?"; எதிரொலி "வாழ்க்கை எப்படி இருக்கிறது? $பெயர்"; எதிரொலி "வாழ்க்கை எப்படி இருக்கிறது?".$பெயர்; // தவறான எதிரொலி "நீங்கள் எப்படி இருக்கிறீர்கள்? $பெயர்";

ஒற்றை மற்றும் இரட்டை மேற்கோள்களில் சிறப்பு எழுத்துக்கள்

எடுத்துக்காட்டாக, தாவல் எழுத்து (\t) என்பது ஸ்லாஷ் மற்றும் t என்ற எழுத்தை விட ஒரு தாவல் எழுத்தாக விளக்கப்படுவதை உறுதிசெய்ய, தாவல் எழுத்தைக் கொண்ட உரையின் வரியை இரட்டை மேற்கோள்களில் இணைக்க வேண்டும். நீங்கள் ஒற்றை மேற்கோள்களில் மட்டுமே \' மற்றும் \\ ​​பயன்படுத்த முடியும். மற்ற அனைத்து தப்பிக்கும் வரிசைகளும் (\n, \r, \$, முதலியன) ஒற்றை மேற்கோள்களுக்குள் அனுமதிக்கப்படாது.

// தவறான எதிரொலி "நீங்கள் எப்படி இருக்கிறீர்கள்?\n"; // சரியான எதிரொலி "நீங்கள் எப்படி இருக்கிறீர்கள்?\n";

ஒரு சரத்திற்குள் இரட்டை மேற்கோள்களில் இருந்து தப்பிக்க, பின்சாய்வுக்கு முன் மேற்கோள்களை வைக்கவும் \" .

// தவறான எதிரொலி"

என்ன விஷயம்?

"; // சரியான எதிரொலி"

என்ன விஷயம்?

"; எதிரொலி"

என்ன விஷயம்?

";

PHP இல் இரட்டை மேற்கோள்கள்

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

$query = "அட்டவணைக்குள் நுழைக்கவும் (இடுகை, ஆசிரியர், உரை, தேதி) மதிப்புகள் ("$id","$author","$text","$date"");

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

.NET அல்லது C மொழியில், ஒற்றை மேற்கோள்களில் இருந்தால், அது ஒரு எழுத்து மற்றும் சரம் அல்ல என்று எனக்கு தெரியும்.

தீர்வு

நீங்கள் என்ன தெரிந்து கொள்ள வேண்டும்

$a = "பெயர்"; $b = "my $a"; == "என் பெயர்" $c = "my $a"; != "என் பெயர்"

PHP இல், "a" , "my name" , "abc xyz" போன்ற நிலையான சரத்தை வரையறுக்க ஒற்றை மேற்கோள்களைப் பயன்படுத்துகின்றனர், அதே நேரத்தில் "a $b $c $d" போன்ற அடையாளங்காட்டியைக் கொண்ட சரத்தை வரையறுக்க இரட்டை மேற்கோளைப் பயன்படுத்துகின்றனர்.

மற்றும் மற்றொரு விஷயம்

எதிரொலி "என் பெயர்";

விட விரைவாக

எதிரொலி "என் பெயர்";

எதிரொலி "என்" . $a;

விட மெதுவாக

எதிரொலி "மை $a";

பயன்படுத்தப்படும் பிற சரங்களுக்கு இது பொருந்தும்.

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

$test = "மாறி"; எதிரொலி "ஹலோ Mr $test"; // வெளியீடு: ஹலோ மிஸ்டர் மாறி எதிரொலி "ஹலோ மிஸ்டர் $ டெஸ்ட்"; // வெளியீடு: ஹலோ Mr $test

இங்கே இரட்டை மேற்கோள் மதிப்பைப் பாகுபடுத்துகிறது மற்றும் ஒற்றை மேற்கோள் சர மதிப்பாகக் கருதப்படுகிறது ($test மாறியைப் பாகுபடுத்தாமல்.)

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

ஒரு சரத்தை வரையறுப்பதற்கான எளிய வழி, அதை ஒற்றை மேற்கோள்களில் (குறியீடு) இணைப்பதாகும் " ).

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

எதிரொலி "இது ஒரு எளிய சரம்";

எதிரொலி "நீங்கள் வரிகளிலும் செருகலாம்
இது போன்ற புதிய வரி பாத்திரம்,
இது நன்று";

// வெளியீடுகள்: அர்னால்ட் ஒருமுறை கூறினார்: "நான் திரும்பி வருவேன்"
எதிரொலி "ஒரு நாள் அர்னால்ட், "நான் திரும்பி வருவேன்" என்றார்.;

எதிரொலி "சி:\\*.* ஐ நீக்கிவிட்டீர்களா?";

// வெளியீடுகள்: நீங்கள் C:\*.* ஐ நீக்கினீர்களா?
எதிரொலி "சி:\*.* ஐ நீக்கினீர்களா?" ;

// வெளியீடுகள்: இது விரிவாக்கப்படாது: \n புதிய வரி
எதிரொலி "இது விரிவாக்கப்படாது: \n புதிய வரி";

// வெளியீடுகள்: $expand மற்றும் $எந்த மாறிகளும் விரிவாக்கப்படவில்லை
எதிரொலி "$expand மற்றும் $எந்த மாறிகளும் விரிவாக்கப்படவில்லை";
?>

இரட்டை மேற்கோள்கள்

சரம் இரட்டை மேற்கோள்களில் (") இணைக்கப்பட்டிருந்தால், PHP சிறப்பு எழுத்துகளுக்கான கூடுதல் தப்பிக்கும் தொடர்களை அங்கீகரிக்கிறது:

எஸ்கேப் தொடர்கள்

பின்தொடர்	பொருள்
\n	புதிய வரி (LF அல்லது 0x0A (10) ASCII இல்)
\r	வண்டி திரும்ப (CR அல்லது 0x0D (13) ASCII இல்)
\t	கிடைமட்ட தாவல் (HT அல்லது ASCII இல் 0x09 (9))
\v	செங்குத்து தாவல் (ASCII இல் VT அல்லது 0x0B (11)) (PHP 5.2.5 முதல்)
\e	தப்பிக்கும் எழுத்து (ESC அல்லது 0x1B (27) ASCII இல்) (PHP 5.4.4 முதல்)
\f	பக்க ஊட்டம் (ASCII இல் FF அல்லது 0x0C (12)) (PHP 5.2.5 முதல்)
\\	பின்சாய்வு
\$	டாலர் அடையாளம்
\"	இரட்டை மேற்கோள்
\{1,3}	எண்முறை எண் அமைப்பில் ஒரு எழுத்தின் வழக்கமான வெளிப்பாட்டுடன் தொடர்புடைய எழுத்துகளின் வரிசை
\x(1,2)	ஹெக்ஸாடெசிமல் குறியீட்டில் ஒரு பாத்திரத்தின் வழக்கமான வெளிப்பாட்டுடன் தொடர்புடைய எழுத்துக்களின் வரிசை

ஒற்றை மேற்கோள்களில் இணைக்கப்பட்ட ஒரு சரத்தைப் போலவே, எந்த கதாபாத்திரத்திலிருந்தும் தப்பிப்பது பின்சாய்வுகளையே வெளியிடும். PHP 5.1.1 க்கு முன், பின்சாய்வு இன் \($var)வெளியிடப்படவில்லை.

மரபுவழி

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

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

கவனம்

மூடும் அடையாளங்காட்டி வரியில் அரைப்புள்ளியைத் தவிர வேறு எந்த எழுத்துகளும் இருக்கக்கூடாது என்பதைக் கவனத்தில் கொள்ள வேண்டும் ( ; ) இதன் பொருள் ஐடி உள்தள்ளப்படக்கூடாதுஅரைப்புள்ளிக்கு முன்னும் பின்னும் இடைவெளிகள் அல்லது தாவல்கள் இருக்கக்கூடாது. மூடும் அடையாளங்காட்டிக்கு முன் உள்ள முதல் எழுத்து உங்கள் இயக்க முறைமையால் வரையறுக்கப்பட்ட புதிய வரி எழுத்தாக இருக்க வேண்டும் என்பதையும் புரிந்து கொள்ள வேண்டியது அவசியம். எடுத்துக்காட்டாக, Mac OS X உட்பட UNIX கணினிகளில், இது \n. மூடும் அடையாளங்காட்டிக்குப் பிறகு உடனடியாக ஒரு புதிய வரியும் தொடங்க வேண்டும்.

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

கிளாஸ் புலங்களை துவக்க ஹெரெடாக் பயன்படுத்த முடியாது. PHP 5.3 இலிருந்து தொடங்கி, இந்த கட்டுப்பாடு மாறிகள் கொண்ட ஹெரெடோக்களுக்கு மட்டுமே பொருந்தும்.

எடுத்துக்காட்டு #1 தவறான உதாரணம்

வகுப்பு foo(
பொது $bar =<<மதுக்கூடம்
EOT;
}
?>

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

எடுத்துக்காட்டு #2 ஒரு ஹெரெடோக் சரத்தை வரையறுப்பதற்கான எடுத்துக்காட்டு

$str =<<எடுத்துக்காட்டு வரி,
பல வரிகளை உள்ளடக்கியது,
ஹெரெடோக் தொடரியல் பயன்படுத்தி.
EOD;

வகுப்பு foo
{
var $foo ;
var $bar ;

செயல்பாடு foo()
{
$this -> foo = "Foo" ;
$இது ->
}
}

$foo = புதிய foo();
$பெயர் = "MyName" ;

எதிரொலி<<என் பெயர் "$பெயர்". நான் $foo -> foo என டைப் செய்கிறேன் .
இப்போது நான் கணிக்கிறேன்($foo -> பார் [1 ]) .
இது "A" என்ற பெரிய எழுத்தை வெளியிட வேண்டும்: \x41
EOT;
?>

என் பெயர் "MyName". நான் Foo என டைப் செய்கிறேன். இப்போது நான் பார் 2 ஐ வெளியிடுகிறேன். இது "A" என்ற பெரிய எழுத்தை வெளியிட வேண்டும்: A

செயல்பாட்டு வாதங்கள் மூலம் தரவை அனுப்ப ஹெரெடோக் தொடரியல் பயன்படுத்தவும் முடியும்:

பதிப்பு 5.3.0 இலிருந்து, ஹெர்டோக் தொடரியல் பயன்படுத்தி நிலையான மாறிகள் மற்றும் வகுப்பு பண்புகள்/மாற்றுகளை துவக்குவது சாத்தியமாகியுள்ளது:

எடுத்துக்காட்டு #4 நிலையான மாறிகளை துவக்க ஹெரெடோக்கைப் பயன்படுத்துதல்

// நிலையான மாறிகள்
செயல்பாடு foo()
{
நிலையான $ பார் =<<இங்கே எதுவும் இல்லை...
லேபிள்;
}

// வகுப்பு பண்புகள்/நிலைகள்
வகுப்பு foo
{
const BAR =<<மாறிலியைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டு
ஃபூபார்;

பொது $baz =<<புலத்தைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டு
ஃபூபார்;
}
?>

PHP 5.3.0 இன் படி, நீங்கள் ஹெரேடாக் அடையாளங்காட்டியை இரட்டை மேற்கோள்களுடன் சுற்றிக்கொள்ளலாம்:

Nowdoc

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

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

எடுத்துக்காட்டு #6 Nowdoc உதாரணம்

$str =<<<"EOD"
எடுத்துக்காட்டு உரை,
பல வரிகளை விரித்து
nowdoc தொடரியல் பயன்படுத்தி.
EOD;

/* மாறிகள் கொண்ட மிகவும் சிக்கலான உதாரணம். */
வகுப்பு foo
{
பொது $foo ;
பொது $bar ;

செயல்பாடு foo()
{
$this -> foo = "Foo" ;
$this -> bar = array("Bar1" , "Bar2" , "Bar3" );
}
}

$foo = புதிய foo();
$பெயர் = "MyName" ;

எதிரொலி<<<"EOT"
என் பெயர் "$பெயர்". நான் $foo->foo ஐ அச்சிடுகிறேன்.
இப்போது நான் அச்சிடுகிறேன் ($foo->bar).
இது ஒரு பெரிய "A" ஐ வெளியிடக்கூடாது: \x41
EOT;
?>

இந்த உதாரணத்தை இயக்குவதன் விளைவு:

என் பெயர் "$பெயர்". நான் $foo->foo ஐ அச்சிடுகிறேன். இப்போது நான் அச்சிடுகிறேன் ($foo->bar). இது ஒரு பெரிய "A" ஐ வெளியிடக்கூடாது: \x41

கருத்து:

ஹெரெடோக் போலல்லாமல், நிலையான தரவுகளுடன் எந்த சூழலிலும் Nowdoc ஐப் பயன்படுத்தலாம். வகுப்பு புலங்கள் அல்லது மாறிலிகளை துவக்குவதற்கான ஒரு பொதுவான எடுத்துக்காட்டு:

எடுத்துக்காட்டு #7 நிலையான தரவைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டு

வகுப்பு foo(
பொது $bar =<<<"EOT"
மதுக்கூடம்
EOT;
}
?>

கருத்து:

nowdoc ஆதரவு PHP 5.3.0 இல் சேர்க்கப்பட்டது.

மாறிகளைக் கையாளுதல்

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

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

வெளிப்பாட்டைச் சுற்றியுள்ள சுருள் பிரேஸ்களால் சிக்கலான தொடரியல் அடையாளம் காண முடியும்.

எளிய தொடரியல்

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

$சாறு = "ஆப்பிள்" ;

எதிரொலி "அவர் கொஞ்சம் $ஜூஸ் ஜூஸ் குடித்தார்." . PHP_EOL ;
// வேலை செய்யாது, "s" என்பது மாறி பெயருக்கான சரியான எழுத்து,
// ஆனால் எங்கள் மாறிக்கு $juice என்று பெயரிடப்பட்டுள்ளது.
எதிரொலி "அவர் $சாறுகளால் செய்யப்பட்ட சில ஜூஸைக் குடித்தார்." ;
?>

இந்த உதாரணத்தை இயக்குவதன் விளைவு:

கொஞ்சம் ஆப்பிள் ஜூஸ் குடித்தார். அதில் செய்த ஜூஸைக் குடித்தார்.

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

எடுத்துக்காட்டு #8 எளிய தொடரியல் உதாரணம்

$juices = வரிசை("ஆப்பிள்" , "ஆரஞ்சு" , "koolaid1" => "ஊதா" );

எதிரொலி "அவர் சில $ஜூஸ் [0 ] ஜூஸ் குடித்தார்." . PHP_EOL ;
எதிரொலி "அவர் சில $ஜூஸ் [1 ] ஜூஸ் குடித்தார்." . PHP_EOL ;
எதிரொலி "அவர் சில $ஜூஸ்கள் [koolaid1] ஜூஸ் குடித்தார்." . PHP_EOL ;

வர்க்க மக்கள் (
பொது $ஜான் = "ஜான் ஸ்மித்" ;
பொது $ஜேன் = "ஜேன் ஸ்மித்" ;
பொது $ராபர்ட் = "ராபர்ட் பால்சென்" ;

பொது $ஸ்மித் = "ஸ்மித்" ;
}

$ மக்கள் = புதிய நபர்கள்();

எதிரொலி "$மக்கள் -> ஜான் சில $ஜூஸ் [0 ] ஜூஸ் குடித்தார்." . PHP_EOL ;
எதிரொலி "$மக்கள் -> ஜான் பின்னர் $பேருக்கு வணக்கம் சொன்னார் -> ஜேன் ." . PHP_EOL ;
எதிரொலி "$மக்கள் -> ஜானின் மனைவி $பீப்பிள் -> ராபர்ட்டை வாழ்த்தினார்." . PHP_EOL;
எதிரொலி " $ மக்கள் -> ராபர்ட் இரண்டு $ மக்கள் -> ஸ்மித்களை வாழ்த்தினார் ." ; // வேலை செய்யாது
?>

இந்த உதாரணத்தை இயக்குவதன் விளைவு:

கொஞ்சம் ஆப்பிள் ஜூஸ் குடித்தார். கொஞ்சம் ஆரஞ்சு ஜூஸ் குடித்தார். கொஞ்சம் ஊதா ஜூஸ் குடித்தார். ஜான் ஸ்மித் கொஞ்சம் ஆப்பிள் ஜூஸ் குடித்தார். அப்போது ஜான் ஸ்மித் ஜேன் ஸ்மித்துக்கு வணக்கம் சொன்னார். ஜான் ஸ்மித்தின் மனைவி ராபர்ட் பால்சனை வாழ்த்தினார்.ராபர்ட் பால்சன் இருவரையும் வாழ்த்தினார்.

மிகவும் சிக்கலான எதற்கும், சிக்கலான தொடரியல் பயன்படுத்தவும்.

சிக்கலான (சுருள்) தொடரியல்

இது சிக்கலானது என்று அழைக்கப்படுகிறது, புரிந்துகொள்வது கடினம் என்பதால் அல்ல, ஆனால் சிக்கலான வெளிப்பாடுகளைப் பயன்படுத்த அனுமதிக்கிறது.

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

// எல்லா பிழைகளையும் காட்டு
பிழை_அறிக்கையிடல்(E_ALL);

$பெரிய = "பெரிய" ;

// வேலை செய்யவில்லை, வெளியீடுகள்: இது (பெரியது)
எதிரொலி "இது ($பெரியது)" ;

// படைப்புகள், வெளியீடுகள்: இது நன்றாக இருக்கிறது
எதிரொலி "இது ($பெரியது)" ;
எதிரொலி "இது $(சிறந்தது)" ;

// வேலை செய்கிறது
எதிரொலி "இந்தச் சதுரம் அகலமானது($சதுரம் -> அகலம்) 00 சென்டிமீட்டர்." ;

// படைப்புகள், மேற்கோள் காட்டப்பட்ட முக்கிய வார்த்தைகள் சுருள் பிரேஸ் தொடரியல் மூலம் மட்டுமே செயல்படும்
எதிரொலி "இது வேலை செய்கிறது: ( $arr [ "key" ]) " ;

// வேலை செய்கிறது
எதிரொலி "இது வேலை செய்கிறது: ( $arr [ 4 ][ 3 ]) " ;

// வெளியில் $foo போன்ற அதே காரணத்திற்காக இது தவறானது
// கோடுகள். வேறு வார்த்தைகளில் கூறுவதானால், அது இன்னும் வேலை செய்யும்.
// ஆனால் PHP முதலில் நிலையான foo ஐ தேடுவதால், இது ஏற்படுத்தும்
// நிலை பிழை E_NOTICE (வரையறுக்கப்படாத மாறிலி).
எதிரொலி "இது சரியல்ல:( $arr [ foo ][ 3 ]) " ;

// வேலை செய்கிறது. பல பரிமாண வரிசைகளை உள்நாட்டில் பயன்படுத்தும் போது
// கோடுகள் எப்போதும் சுருள் பிரேஸ்களைப் பயன்படுத்துகின்றன
எதிரொலி "இது வேலை செய்கிறது: ( $arr [ "foo" ][ 3 ]) " ;

// வேலை செய்கிறது.
எதிரொலி "இது வேலை செய்கிறது:" . $arr [ "foo" ][ 3 ];

எதிரொலி "இதுவும் வேலை செய்கிறது:($obj -> மதிப்புகள் [3]-> பெயர்) ";

எதிரொலி "இது பெயரிடப்பட்ட மாறியின் மதிப்பு$பெயர் : ($( $name )) " ;

எதிரொலி "இது getName() வழங்கும் மாறி பெயரின் மதிப்பு:($( getName ())) " ;

எதிரொலி "இது \$object->getName() வழங்கும் பெயரின் மாறியின் மதிப்பு:($( $object -> getName ())) " ;

// வேலை செய்யாது, வெளியீடுகள்: இது getName() திரும்பும்: (getName())
எதிரொலி "இதுவே getName() வழங்கும்: (getName())";
?>

இந்த தொடரியல் பயன்படுத்தி சரங்களுக்குள் பொருள் பண்புகளை அணுகவும் முடியும்.

வகுப்பு foo(
var $bar = "நான் பார்." ;
}

$foo = புதிய foo();
$bar = "பார்" ;
$baz = array("foo" , "bar" , "baz" , "quux" );
எதிரொலி " ( $foo -> $bar ) \n" ;
எதிரொலி " ( $foo -> $baz [ 1 ]) \n" ;
?>

இந்த உதாரணத்தை இயக்குவதன் விளைவு:

நான் பார். நான் பார்.

கருத்து:

செயல்பாடுகள், முறை அழைப்புகள், நிலையான வகுப்பு மாறிகள் மற்றும் வகுப்பு மாறிலிகள் ஆகியவை உள்நாட்டில் செயல்படுகின்றன {$} , PHP 5 இல் தொடங்கி. இருப்பினும், வழங்கப்பட்ட மதிப்பு, அது வரையறுக்கப்பட்ட வரியின் அதே சூழலில் மாறி பெயராகக் கருதப்படும். ஒற்றை சுருள் பிரேஸ்களைப் பயன்படுத்துதல் ( {} ) செயல்பாடுகள், முறைகள், வர்க்க மாறிலிகள் அல்லது நிலையான வகுப்பு மாறிகளின் மதிப்புகளை அணுகுவதற்கு வேலை செய்யாது.

// எல்லா பிழைகளையும் காட்டு
பிழை_அறிக்கையிடல்(E_ALL);

வகுப்பு பியர்ஸ் (
const softdrink = "rootbeer" ;
பொது நிலையான $ale = "ipa" ;
}

$rootbeer = "A & W" ;
$ipa = "Alexander Keith\"s" ;

// இது வேலை செய்கிறது, வெளியீடுகள்: நான் A & W ஐ விரும்புகிறேன்
எதிரொலி "நான் விரும்புகிறேன் ($(பியர்ஸ் :: மென்பானம்)) \n" ;

// இதுவும் வேலை செய்கிறது, வெளியீடுகள்: நான் அலெக்சாண்டர் கீத்ஸை விரும்புகிறேன்
எதிரொலி "நான் விரும்புகிறேன் ($(பியர்ஸ் :: $ale )) \n" ;
?>

ஒரு சரத்தில் ஒரு எழுத்தை அணுகுதல் மற்றும் மாற்றுதல்

சரத்தின் தொடக்கத்தில் இருந்து, பூஜ்ஜியத்தில் தொடங்கி, சரத்திற்குப் பின் சதுர அடைப்புக்குறிக்குள், எடுத்துக்காட்டாக, $str . இந்த நோக்கத்திற்காக ஒரு சரத்தை எழுத்துக்களின் வரிசையாக நினைத்துப் பாருங்கள். நீங்கள் 1 எழுத்துக்கு மேல் பெற அல்லது மாற்ற வேண்டும் என்றால், நீங்கள் செயல்பாடுகளைப் பயன்படுத்தலாம் substr()மற்றும் substr_replace().

கருத்து: ஒரு சரத்தில் உள்ள எழுத்தை சுருள் பிரேஸ்களைப் பயன்படுத்தி அணுகலாம், எடுத்துக்காட்டாக $str(42) .

கவனம்

வரியின் எல்லைகளுக்கு அப்பால் ஒரு ஆஃப்செட்டில் எழுத முயற்சிப்பது அந்த ஆஃப்செட் வரையிலான இடைவெளிகளுடன் சரத்தை திணிக்கும். முழு எண் அல்லாத வகைகள் முழு எண் வகைகளாக மாற்றப்படும். தவறான ஆஃப்செட் வகை ஒரு நிலைப் பிழையை ஏற்படுத்தும் E_NOTICE. எதிர்மறை ஆஃப்செட்டில் எழுதுவது நிலைப் பிழையை ஏற்படுத்தும் E_NOTICE, மற்றும் படிக்கும் போது அது ஒரு வெற்று சரத்தை வழங்கும். ஒதுக்கப்பட்ட சரத்தின் முதல் எழுத்து மட்டுமே பயன்படுத்தப்படுகிறது. வெற்று சரத்திற்கு ஒதுக்குவது ஒரு பூஜ்ய பைட்டை (NULL) ஒதுக்குகிறது.

கவனம்

PHP இல் உள்ள சரங்கள் பைட்டுகளின் உள் வரிசைகள். இதன் விளைவாக, ஆஃப்செட்டில் ஒரு சரத்தை அணுகுவது அல்லது மாற்றுவது பல பைட் குறியாக்கம் பாதுகாப்பானது அல்ல, மேலும் ISO-8859-1 போன்ற ஒற்றை-பைட் குறியாக்கங்களில் உள்ள சரங்களைக் கொண்டு மட்டுமே செய்யப்பட வேண்டும்.

எடுத்துக்காட்டு #9 சில எடுத்துக்காட்டு சரங்கள்

// சரத்தின் முதல் எழுத்தைப் பெறவும்
$str = "இது ஒரு சோதனை." ;
$first = $str [0 ];

// சரத்தின் மூன்றாவது எழுத்தைப் பெறவும்
$மூன்றாம் = $str [2];

// சரத்தின் கடைசி எழுத்தைப் பெறுங்கள்
$str = "இது இன்னும் ஒரு சோதனை." ;
$last = $str [ strlen ($str ) - 1 ];

// வரியின் கடைசி எழுத்தை மாற்றவும்
$str = "கடலைப் பார்" ;
$str [ strlen ($str )- 1 ] = "e" ;

?>

PHP 5.4 இன் படி, சரத்தில் உள்ள ஆஃப்செட் ஒரு முழு எண்ணாகவோ அல்லது இலக்கங்களைக் கொண்ட சரமாகவோ குறிப்பிடப்பட வேண்டும், இல்லையெனில் எச்சரிக்கை வழங்கப்படும். முன்பு போன்ற ஒரு சரத்தால் ஆஃப்செட் செய்யப்பட்டது "foo", எச்சரிக்கை இல்லாமல் மாற்றப்பட்டது 0 .

எடுத்துக்காட்டு #10 PHP 5.3 மற்றும் PHP 5.4 இடையே உள்ள வேறுபாடுகள்

$str = "abc" ;

Var_dump($str["1"]);
var_dump (isset($str [ "1" ]));

Var_dump($str["1.0"]);
var_dump (isset($str [ "1.0" ]));

Var_dump($str["x"]);
var_dump (isset($str [ "x" ]));

Var_dump($str["1x"]);
var_dump (isset($str [ "1x" ]));
?>

இந்த உதாரணத்தை PHP 5.3 இல் இயக்குவதன் முடிவு:

சரம்(1) "b" bool(true) string(1) "b" bool(true) string(1) "a" bool(true) string(1) "b" bool(true)

இந்த உதாரணத்தை PHP 5.4 இல் இயக்குவதன் முடிவு:

string(1) "b" bool(true) எச்சரிக்கை: /tmp/t.php இல் "1.0" இன் சட்டவிரோத சரம் ஆஃப்செட் tmp/t.php வரி 9 சரம்(1) "a" bool(false) string(1) "b" bool(false)

கருத்து:

பிற வகைகளின் மாறிகளை அணுக முயல்கிறது (சில இடைமுகங்களைச் செயல்படுத்தும் வரிசைகள் அல்லது பொருள்களைத் தவிர்த்து) அல்லது {} அமைதியாக திரும்பும் ஏதுமில்லை.

கருத்து:

PHP 5.5 தொடரியலைப் பயன்படுத்தி ஸ்டிரிங் லிட்டரலில் உள்ள எழுத்துக்களை அணுகுவதற்கான ஆதரவைச் சேர்த்தது அல்லது {} .

சரங்களை மாற்றுவதற்கு பல பயனுள்ள செயல்பாடுகள் உள்ளன.

அடிப்படை செயல்பாடுகள் சரம் செயல்பாடுகள் மற்றும் மேம்பட்ட தேடல் மற்றும் மாற்று, வழக்கமான வெளிப்பாடு அல்லது பெர்ல்-இணக்கமான வழக்கமான வெளிப்பாடு செயல்பாடுகள் பிரிவில் விவரிக்கப்பட்டுள்ளன.

சரமாக மாற்றவும்

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

வரிசைகள் எப்போதும் சரமாக மாற்றப்படும் "வரிசை", எனவே நீங்கள் வரிசையின் உள்ளடக்கங்களைக் காட்ட முடியாது ( வரிசை), பயன்படுத்தி எதிரொலிஅல்லது அச்சுஅதில் என்ன இருக்கிறது என்று பார்க்க. ஒற்றை உறுப்பைப் பார்க்க, இதுபோன்ற ஒன்றைப் பயன்படுத்தவும் எதிரொலி $arr["foo"]. எல்லா உள்ளடக்கத்தையும் காண்பிப்பது/பார்ப்பது எப்படி என்பதற்கான உதவிக்குறிப்புகளுக்கு கீழே பார்க்கவும்.

PHP 4 இல் உள்ள பொருள்கள் எப்போதும் சரமாக மாற்றப்படும் "பொருள்". நீங்கள் ஒரு பொருளின் புலங்களின் மதிப்புகளைக் காட்ட விரும்பினால் ( பொருள்) பிழைத்திருத்த நோக்கங்களுக்காக, படிக்கவும். தேவையான பொருளின் வகுப்புப் பெயரைப் பெற விரும்பினால், பயன்படுத்தவும் get_class(). PHP 5 இலிருந்து, __toString முறையும் கிடைக்கிறது.

ஏதுமில்லைஎப்போதும் வெற்று சரமாக மாற்றப்படும்.

நீங்கள் மேலே பார்ப்பது போல், வரிசைகள், பொருள்கள் அல்லது ஆதாரங்களை நேரடியாக சரமாக மாற்றுவது அவற்றின் வகைகளைத் தவிர மதிப்புகளைப் பற்றிய எந்த பயனுள்ள தகவலையும் வழங்காது. பிழைத்திருத்தத்திற்கான மதிப்புகளை வெளியிடுவதற்கான சிறந்த வழி செயல்பாடுகளைப் பயன்படுத்துவதாகும் print_r()மற்றும் var_dump().

PHP இல் உள்ள பெரும்பாலான மதிப்புகள் நிலையான சேமிப்பிற்காக ஒரு சரமாக மாற்றப்படலாம். இந்த முறை வரிசைப்படுத்தல் என்று அழைக்கப்படுகிறது மற்றும் செயல்பாட்டைப் பயன்படுத்தி செய்யலாம் வரிசைப்படுத்து(). கூடுதலாக, உங்கள் PHP நிறுவலுக்கு WDDX ஆதரவு இருந்தால், XML கட்டமைப்பிற்கான வரிசைப்படுத்தலும் சாத்தியமாகும்.

சரங்களை எண்களாக மாற்றுகிறது

சரம் ஒரு எண் மதிப்பாக அங்கீகரிக்கப்பட்டால், அதன் விளைவாக வரும் மதிப்பு மற்றும் வகை பின்வருமாறு தீர்மானிக்கப்படும்.

சரத்தில் ".", "e" அல்லது "E" எழுத்துகள் எதுவும் இல்லை என்றால், எண்ணின் மதிப்பு முழு எண்களின் வரம்பிற்குள் இருந்தால் (வரையறுக்கப்பட்டது PHP_INT_MAX), சரம் முழு எண்ணாக அங்கீகரிக்கப்படும் ( முழு) மற்ற எல்லா நிகழ்வுகளிலும் இது ஒரு மிதக்கும் புள்ளி எண்ணாகக் கருதப்படுகிறது ( மிதவை).

சரத்தின் தொடக்கத்தால் மதிப்பு தீர்மானிக்கப்படுகிறது. வரி சரியான எண் மதிப்புடன் தொடங்கினால், அந்த மதிப்பு பயன்படுத்தப்படும். இல்லையெனில் மதிப்பு 0 (பூஜ்ஜியம்) ஆக இருக்கும். செல்லுபடியாகும் எண் மதிப்பு என்பது ஒன்று அல்லது அதற்கு மேற்பட்ட இலக்கங்கள் (இதில் ஒரு தசம புள்ளி இருக்கலாம்), விருப்பமாக ஒரு அடையாளத்திற்கு முன்னால், அதைத் தொடர்ந்து ஒரு விருப்ப அடுக்கு. அடுக்கு என்பது "e" அல்லது "E" ஐத் தொடர்ந்து ஒன்று அல்லது அதற்கு மேற்பட்ட இலக்கங்கள்.

$foo = 1 + "10.5" ; // $foo ஒரு மிதவை (11.5)
$foo = 1 + "-1.3e3" ; // $foo ஒரு மிதவை (-1299)
$foo = 1 + "bob-1.3e3" ; // $foo ஒரு முழு எண் (1)
$foo = 1 + "bob3" ; // $foo ஒரு முழு எண் (1)
$foo = 1 + "10 சிறிய பன்றிகள்" ; // $foo ஒரு முழு எண் (11)
$foo = 4 + "10.2 Little Piggies" ; // $foo ஒரு மிதவை (14.2)
$foo = "10.0 பன்றிகள்" + 1 ; // $foo மிதவை (11)
$foo = "10.0 பன்றிகள்" + 1.0 ; // $foo மிதவை (11)
?>

மேலும் விரிவான தகவல்இந்த மாற்றத்தைப் பற்றிய தகவலுக்கு, Unix ஆவணத்தில் உள்ள strtod(3) பிரிவைப் பார்க்கவும்.

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

எதிரொலி "\$foo== $foo ; வகை: " . gettype ($foo) . "
\n" ;
?>

ஒரு முழு எண்ணாக மாற்றுவதன் மூலம் ஒரு எழுத்தின் குறியீட்டைப் பெற எதிர்பார்க்க வேண்டாம் (உதாரணமாக, C இல்). எழுத்துகளை அவற்றின் ASCII குறியீடுகளாகவும், பின்னாகவும் மாற்ற, செயல்பாடுகளைப் பயன்படுத்தவும் ord()மற்றும் chr().

சரம் வகை செயல்படுத்தல் விவரங்கள்

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

சரம் வகையின் இந்த இயல்பு PHPக்கு ஏன் தனி “பைட்” வகை இல்லை என்பதை விளக்குகிறது - சரங்கள் அந்த பாத்திரத்தை வகிக்கின்றன. உரை அல்லாத தரவை வழங்கும் செயல்பாடுகள்-உதாரணமாக, பிணைய சாக்கெட்டில் இருந்து படிக்கப்பட்ட தன்னிச்சையான தரவு ஸ்ட்ரீம்-இன்னும் சரங்களைத் தருகிறது.

PHP ஆனது சரங்களுக்கு ஒரு குறிப்பிட்ட குறியாக்கத்தைக் கட்டளையிடவில்லை என்ற உண்மையைக் கருத்தில் கொண்டு, சரம் எழுத்துக்கள் எவ்வாறு குறியாக்கம் செய்யப்படுகின்றன என்று ஒருவர் கேட்கலாம். உதாரணமாக, வரி "á" இணையான "\xE1"(ISO-8859-1), "\xC3\xA1"(UTF-8, இயல்பாக்கம் படிவம் C), "\x61\xCC\x81"(UTF-8, இயல்பாக்கம் படிவம் D) அல்லது வேறு ஏதேனும் சாத்தியமான பிரதிநிதித்துவமா? ஸ்கிரிப்ட் கோப்பில் எழுதப்பட்ட விதத்தில் சரம் குறியாக்கம் செய்யப்படும் என்பது பதில். எனவே, ஸ்கிரிப்ட் ஐஎஸ்ஓ-8859-1 குறியாக்கத்தில் எழுதப்பட்டால், சரம் ஐஎஸ்ஓ-8859-1 போன்றவற்றில் குறியாக்கம் செய்யப்படும். இருப்பினும், Zend Multibyte பயன்முறை இயக்கப்பட்டிருக்கும் போது இந்த விதி பொருந்தாது: இந்த வழக்கில், ஸ்கிரிப்ட் எந்த குறியாக்கத்திலும் எழுதப்படலாம் (வெளிப்படையாக குறிப்பிடப்பட்ட அல்லது தானாகவே தீர்மானிக்கப்படும்), பின்னர் ஒரு குறிப்பிட்ட உள் குறியாக்கத்திற்கு மாற்றப்படும், இது பின்னர் பயன்படுத்தப்படும் சரம் எழுத்துக்கள். ஸ்கிரிப்ட் குறியாக்கம் (அல்லது Zend Multibyte இயக்கப்பட்டிருந்தால் உள் குறியாக்கம்) சில கட்டுப்பாடுகளைக் கொண்டுள்ளது என்பதை நினைவில் கொள்ளவும்: குறியாக்கம் எப்போதும் UTF-8 அல்லது ISO-8859-1 போன்ற ASCII இன் சூப்பர்செட்டாக இருக்க வேண்டும். அதே பைட் மதிப்புகள் ஆரம்ப மற்றும் தொடக்க நிலை அல்லாத மாற்ற நிலையில் பயன்படுத்தப்படும் நிலை சார்ந்த குறியாக்கங்கள் சிக்கல்களை ஏற்படுத்தலாம் என்பதையும் கவனத்தில் கொள்ளவும்.

நிச்சயமாக, பயனுள்ளதாக இருக்க, சரம் செயல்பாடுகள் சரத்தின் குறியாக்கத்தைப் பற்றி சில அனுமானங்களைச் செய்ய வேண்டும். துரதிர்ஷ்டவசமாக, PHP செயல்பாடுகளில் இந்த சிக்கலுக்கு பல்வேறு வகையான அணுகுமுறைகள் உள்ளன:

• சில செயல்பாடுகள் சரம் சில ஒற்றை-பைட் குறியாக்கத்தில் குறியாக்கம் செய்யப்பட்டுள்ளது என்று கருதுகின்றன, ஆனால் அவை சரியாக வேலை செய்ய பைட்டுகளை குறிப்பிட்ட எழுத்துக்களாக விளக்க வேண்டிய அவசியமில்லை. இந்த வகை அடங்கும், எடுத்துக்காட்டாக, substr(), strpos(), strlen()மற்றும் strcmp(). இந்த செயல்பாடுகளைப் பற்றி சிந்திக்க மற்றொரு வழி, அவை நினைவக இடையகங்களில் செயல்படுகின்றன, அதாவது. அவை பைட்டுகள் மற்றும் அவற்றின் ஆஃப்செட்களுடன் நேரடியாக வேலை செய்கின்றன. ஆஃப்செட்டுகள்.
• மற்ற செயல்பாடுகள் ஒரு குறியாக்கம் ஒரு அளவுருவாக அனுப்பப்படும் என்று எதிர்பார்க்கிறது, ஒருவேளை குறியாக்க அளவுரு குறிப்பிடப்படவில்லை என்றால் சில இயல்புநிலை குறியாக்கத்தை அனுமானிக்கலாம். இந்த செயல்பாடு உள்ளது
• இறுதியாக, ஒரு சரம் ஒரு குறிப்பிட்ட குறியாக்கத்தைப் பயன்படுத்துகிறது என்று கருதும் செயல்பாடுகள் உள்ளன, பொதுவாக UTF-8. intl மற்றும் PCRE நீட்டிப்புகளின் பெரும்பாலான செயல்பாடுகள் இங்கே விழும் (பிந்தைய வழக்கில், மாற்றியைக் குறிப்பிடும்போது மட்டுமே u) இது வேண்டுமென்றே செய்யப்பட்டாலும், செயல்பாடு utf8_decode() UTF-8 குறியாக்கத்தைக் குறிக்கிறது, மற்றும் utf8_encode()- ISO-8859-1.

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

சரங்களை வடிவமைக்க நான் எந்த வகையான மேற்கோள்களைப் பயன்படுத்த வேண்டும் - அப்போஸ்ட்ரோபிகள் அல்லது கிளாசிக் இரட்டை மேற்கோள்கள்?

PHP இல் இரட்டை மற்றும் ஒற்றை மேற்கோள்களுக்கு இடையிலான வேறுபாட்டைப் பார்ப்போம், மேலும் எதை எப்போது பயன்படுத்த வேண்டும் என்பதைக் கண்டறிய எடுத்துக்காட்டுகளைப் பயன்படுத்தவும்.

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

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

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

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

ஒற்றை மேற்கோள்களைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டு இங்கே:
// வெளியீடு: எளிய சரம்
எதிரொலி "எளிய சரம்";
// பிரிண்ட்ஸ்: நான் இங்கே இருக்கிறேன்
எதிரொலி "நான் இங்கே இருக்கிறேன்";
// வெளியீடு: இது செருகாது: \n புதிய வரி
எதிரொலி "இது செருகாது:\nநியூலைன்";
// வெளியீடுகள்: $example மாறியும் மாற்றப்படாது
எதிரொலி "$example மாறியும் மாற்றப்படாது"; சரம் இரட்டை மேற்கோள்களில் (") இணைக்கப்பட்டிருந்தால், PHP அங்கீகரிக்கிறது பெரிய அளவுசிறப்பு எழுத்துகளுக்கான கட்டுப்பாட்டு வரிசைகள் மற்றும் சரத்தில் உள்ள மாறி பெயருக்கு பதிலாக அதன் மதிப்பை மாற்றுகிறது. ஒற்றை மேற்கோள்களைப் போலவே, இரட்டை மேற்கோள் சரத்திற்குள் இரட்டை மேற்கோள்களைப் பயன்படுத்த, அவைகளுக்கு முன் பின்சாய்வு எழுத்து (\) இருக்க வேண்டும்.

இரட்டை மேற்கோள்களைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டு இங்கே:
// வெளியீடு: எளிய சரம்
எதிரொலி "எளிய சரம்";
// வெளியீடுகள்: நிறுவனம் "ஸ்னோ டிராப்"
எதிரொலி "கம்பெனி \"ஸ்னோ டிராப்\"";
// வெளியீடு: இது ஒரு புதிய வரிக்கு வழிவகுக்கும்
எதிரொலி "இது ஒரு புதிய வரியாக உடைக்கும் \n";
// வெளியீடு: மாறி மாற்றப்படும்
$example = "பதிலீடு செய்யப்படும்";
எதிரொலி "மாறி $example"; "\n" வரிசை என்பதையும் நினைவில் கொள்ள வேண்டும் ( புதிய கோடு), "\r" (கேரேஜ் ரிட்டர்ன்) எளிய உரைக்கு, HTML அல்ல. எனவே நீங்கள் உலாவியில் மாற்றங்களைக் காண மாட்டீர்கள் (இல் மட்டும் மூல குறியீடுபக்கங்கள்).

இரட்டை மேற்கோள்களை விட ஒற்றை மேற்கோள்கள் எவ்வளவு வேகமானவை என்பதைக் கண்டுபிடிப்போம். அளவீடுகளுக்கு, நாங்கள் ஒரு குறுகிய சோதனை ஸ்கிரிப்டை எழுதுவோம், அதை நீங்களே சோதித்தால், உங்கள் பிசி அல்லது சர்வரின் வன்பொருளைப் பொறுத்து முடிவுகள் வேறுபட்டதாக இருக்கும் என்பதை நாங்கள் உடனடியாக கவனிப்போம்.
// லூப்பின் தொடக்கத்தில் நேர முத்திரையைத் திருப்பி அனுப்பவும்
$தொடக்கம் = மைக்ரோடைம்(உண்மை);
// 1 மில்லியன் மறு செய்கைகளுக்கு ஒரு வளையத்தை உருவாக்கவும்
க்கு ($i = 0; $i< 1000000; $i++) {
$text = "இதோ ஒரு எழுத்து சரம்";
}
// செலவழித்த நேரத்தை கணக்கிடுங்கள்
$நேரம் = (மைக்ரோடைம்(உண்மை) - $தொடக்கம்); முடிவு: 0.09 வினாடிகள்.

ஒற்றை மேற்கோள்களை இரட்டை மேற்கோள்களுடன் மாற்றினால்:
$text = "இதோ ஒரு எழுத்து சரம்"; முடிவு 0.10 வினாடிகள் இருக்கும்.

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

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

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