Det är ingen hemlighet att citat i PHP kan vara enkla eller dubbla. Låt oss ta reda på när vissa användningar av citattecken är lämpligare.

Enstaka citat

Det enklaste sättet att definiera en sträng är att omge text med enkla citattecken.

Om vi ​​behöver använda ett enda citat i text, måste vi undvika det med ett snedstreck (\).

Escape-sekvenser inom enstaka citattecken fungerar inte.

Exempel på användning av enstaka citattecken:

Dubbla citattecken

Om du markerar text med dubbla citattecken kommer strängen att definieras på samma sätt som med enkla citattecken. Men visst finns det skillnader mellan citat.

Situationen med undvikande citattecken är densamma som med enstaka citattecken.

En sträng som är omgiven av dubbla citattecken känner igen de flesta escape-sekvenser för specialtecken.

Den viktigaste skillnaden är det faktum att dubbla citattecken hanterar variabler.

Exempel på användning av dubbla citattecken:

Låt oss fokusera på det faktum att strängar med dubbla citattecken hanterar variabler.

Vad händer när en sträng bearbetas? Tolk kontrollera varje sträng med dubbla citattecken för variabler, dvs. tvångsanalys sker, vilket tar ytterligare tid. Ja, ofta är detta en delad sekund, men själva faktum måste förstås. Det vill säga om du jämför bearbetningen av en sträng med olika citattecken (utan variabler förstås), så kommer en sträng med enstaka citattecken definitivt att bearbetas snabbare.

Beräkningar

På ProfiPHP-webbplatsen hittade jag intressanta beräkningar för det här ämnet. Författaren skrev ett enkelt manus med vilket han beräknade tiden för att bearbeta strängar.

Den här korta artikeln visar hur och var du ska använda citat i PHP.

Enstaka citat (apostrof) i PHP

Strängar omslutna av enstaka citattecken bearbetas inte på något sätt av PHP. Det vill säga enstaka citattecken representerar texten som är innesluten mellan dem som den är.

// Rätt eko "Hur är livet?"; echo "Hur är livet? $namn"; echo "Hur är livet?".$name; // Felaktigt eko "Hur mår du? $name";

Specialtecken i enkla och dubbla citattecken

För att till exempel säkerställa att tabbtecknet (\t) tolkas som ett tabbtecken snarare än som ett snedstreck och bokstaven t, måste du omge textraden som innehåller tabbtecknet med dubbla citattecken. Du kan bara använda \' och \\ inom enstaka citattecken. Alla andra escape-sekvenser (\n, \r, \$, etc.) är inte tillåtna inom enstaka citattecken.

// Felaktigt eko "Hur mår du?\n"; // Rätt eko "Hur mår du?\n";

För att undvika dubbla citattecken inom en sträng, placera citattecken före omvänt snedstreck \" .

// Felaktigt eko "

Vad händer?

"; // Rätt eko"

Vad händer?

"; eka"

Vad händer?

";

Dubbla citattecken i PHP

Text inom dubbla citattecken behandlas väldigt olika. Till exempel ersätts variabler som omges av dubbla citattecken med deras värden. Detta gör det bekvämt att kompilera SQL-frågor med dubbla citattecken.

$query = "INSERT I tabell (inlägg, författare, text, datum) VÄRDEN ("$id","$author","$text","$date"");

Jag är ingen expert på PHP-programmering, men jag är lite förvirrad varför jag ser en del kod i PHP med en sträng omsluten av enkla och ibland dubbla citattecken.

Jag vet bara att i .NET- eller C-språk, om det är i enstaka citattecken, betyder det att det är ett tecken och inte en sträng.

Lösning

Vad du borde veta

$a = "namn"; $b = "min $a"; == "mitt namn" $c = "min $a"; != "mitt namn"

I PHP använder människor enkla citattecken för att definiera en konstant sträng som "a", "mitt namn", "abc xyz" medan de använder dubbla citattecken för att definiera en sträng som innehåller en identifierare som "a $b $c $d" .

Och en annan sak är

Echo "mitt namn";

snabbare än

Echo "mitt namn";

Echo "min". $a;

långsammare än

Echo "min $a";

Detta gäller för andra använda strängar.

I PHP behandlas text i enkla citattecken som ett strängvärde, medan text i dubbla citattecken kommer att analysera variabler genom att ersätta och bearbeta deras värde.

$test = "variabel"; echo "Hej Mr $test"; // utgången skulle vara: Hello Mr variabel echo "Hello Mr $test"; // utgången skulle vara: Hej Mr $test

Här analyserar det dubbla citattecken värdet och det enkla citattecken behandlas som ett strängvärde (utan att analysera $testvariabeln.)

Båda typerna av kapslade tecken är strängar. Det är bekvämt att använda en typ av offert för att avsluta en annan typ av offert. """ och """. Den största skillnaden mellan citattecken är att kapslade identifierarreferenser ersätts inuti dubbla citattecken snarare än inom enkla citattecken.

Det enklaste sättet att definiera en sträng är att omge den i enkla citattecken (symbolen " ).

Om du vill använda ett enstaka citattecken i en sträng, undviker du det med ett snedstreck ( \ ). Om du behöver skriva själva snedstrecket, duplicera det ( \\ ). All annan användning av omvänt snedstreck kommer att tolkas som normala tecken: det betyder att om du försöker använda andra escape-sekvenser som t.ex. \r eller \n, kommer de att matas ut som de är istället för något speciellt beteende.

eko "det här är en enkel sträng";

eko "Du kan också infoga i rader
nylinjekaraktär som denna,
Det här är okej";

// Utgångar: Arnold sa en gång: "I'll be back"
eko "En dag sa Arnold "Jag kommer tillbaka.";

Eko "Har du tagit bort C:\\*.*?";

// Utgångar: Tog du bort C:\*.*?
echo "Har du tagit bort C:\*.*?" ;

// Utgångar: Detta kommer inte att utökas: \n ny rad
eko "Detta kommer inte att utökas: \n nyrad";

// Utdata: variablerna $expand och $either expanderas inte
eko "variablerna $expand och $either expanderas inte";
?>

Dubbla citattecken

Om strängen är omgiven av dubbla citattecken ("), känner PHP igen fler escape-sekvenser för specialtecken:

Escape Sequences

Efterföljd	Menande
\n	nylinje (LF eller 0x0A (10) i ASCII)
\r	vagnretur (CR eller 0x0D (13) i ASCII)
\t	horisontell flik (HT eller 0x09 (9) i ASCII)
\v	vertikal flik (VT eller 0x0B (11) i ASCII) (sedan PHP 5.2.5)
\e	escape-tecken (ESC eller 0x1B (27) i ASCII) (sedan PHP 5.4.4)
\f	sidflöde (FF eller 0x0C (12) i ASCII) (sedan PHP 5.2.5)
\\	snedstreck
\$	dollartecken
\"	dubbelt citat
\{1,3}	sekvens av tecken som motsvarar ett reguljärt uttryck för ett tecken i oktala talsystem
\x(1,2)	sekvens av tecken som motsvarar det reguljära uttrycket för ett tecken i hexadecimal notation

Precis som med en sträng omsluten av enstaka citattecken, kommer även omvänt snedstreck att matas ut om du undviker ett tecken. Före PHP 5.1.1, snedstreck in \($var) publicerades inte.

Heredoc

Det tredje sättet att definiera strängar är att använda heredoc-syntax: <<< . Efter den här operatorn måste du ange en identifierare och sedan en radmatning. Efter detta kommer själva raden, och sedan samma identifierare, som stänger infogningen.

Linje måste börja med en avslutande identifierare, dvs. den måste visas i den första kolumnen på raden. Dessutom måste identifieraren följa samma namnregler som alla andra taggar i PHP: endast innehålla alfanumeriska tecken och ett understreck, och får inte börja med ett nummer (understreck är tillåtna).

Uppmärksamhet

Det är mycket viktigt att notera att den avslutande identifierarraden inte får innehålla några andra tecken förutom ett semikolon ( ; ). Det betyder att id ska inte indragas och att det inte kan finnas några mellanslag eller tabbar före eller efter semikolon. Det är också viktigt att förstå att det första tecknet före den avslutande identifieraren måste vara ett nyradstecken som definierats av ditt operativsystem. Till exempel på UNIX-system, inklusive Mac OS X, detta \n. En ny rad måste också börja omedelbart efter den avslutande identifieraren.

Om denna regel överträds och den avslutande identifieraren inte är "ren", anses den avslutande identifieraren saknas och PHP kommer att fortsätta leta efter den ytterligare. Om i det här fallet den korrekta stängningsidentifieraren aldrig hittas, kommer det att orsaka ett analysfel med radnumret i slutet av skriptet.

Heredoc kan inte användas för att initiera klassfält. Från och med PHP 5.3 gäller denna begränsning endast heredocs som innehåller variabler.

Exempel #1 Fel exempel

klass foo(
offentlig $bar =<<bar
EOT;
}
?>

Heredoc-text beter sig på samma sätt som en sträng inom dubbla citattecken, utan att ha dem. Det betyder att du inte behöver undkomma citattecken i heredoc, men du kan fortfarande använda escape-sekvenserna ovan. Variabler bearbetas, men du måste vara lika försiktig när du använder komplexa variabler i heredoc som när du arbetar med strängar.

Exempel #2 Exempel på att definiera en heredoc-sträng

$str =<<Exempel rad,
som täcker flera linjer,
använder heredoc-syntax.
EOD;

Klass foo
{
var $foo ;
var $bar ;

Funktion foo()
{
$this -> foo = "Foo" ;
$this ->
}
}

$foo = new foo();
$name = "Mitt Namn" ;

eko<<Mitt namn är "$name". Jag skriver $foo -> foo .
Nu drar jag slutsatsen( $foo -> bar [ 1 ]) .
Detta bör mata ut den stora bokstaven "A": \x41
EOT;
?>

Mitt namn är "MyName". Jag skriver Foo. Nu matar jag ut Bar2. Detta bör mata ut en stor bokstav "A": A

Det är också möjligt att använda heredoc-syntax för att skicka data genom funktionsargument:

Sedan version 5.3.0 har det blivit möjligt att initiera statiska variabler och klassegenskaper/konstanter med heredoc-syntax:

Exempel #4 Använda heredoc för att initiera statiska variabler

// Statiska variabler
funktion foo()
{
statisk $bar =<<Det finns inget här...
MÄRKA;
}

// Klassegenskaper/konstanter
klass foo
{
const BAR =<<Exempel på användning av en konstant
FOO BAR;

Offentlig $baz =<<Exempel på användning av ett fält
FOO BAR;
}
?>

Från och med PHP 5.3.0 kan du även omge Heredoc-identifieraren med dubbla citattecken:

Nowdoc

Nowdoc är samma för strängar med enkla citattecken som heredoc är för strängar med dubbla citat. Nowdoc liknar heredoc, men inuti den inga ersättningar görs. Denna design är idealisk för att bädda in PHP-kod eller andra stora textblock utan att behöva undkomma den. I detta är det lite likt SGML-konstruktionen genom att förklara att ett textblock inte är avsett att bearbetas.

Nowdoc indikeras med samma sekvens <<< , som används i heredoc, men följande identifierare omges av enkla citattecken, t.ex. <<<"EOT" . Alla villkor som gäller för heredoc-identifierare gäller även för nowdoc, speciellt de som gäller för den avslutande identifieraren.

Exempel #6 Nowdoc-exempel

$str =<<<"EOD"
Exempeltext,
spänner över flera linjer
använder nowdoc-syntax.
EOD;

/* Mer komplext exempel med variabler. */
klass foo
{
offentliga $foo ;
offentlig $bar ;

Funktion foo()
{
$this -> foo = "Foo" ;
$this -> bar = array("Bar1" , "Bar2" , "Bar3" );
}
}

$foo = new foo();
$name = "Mitt Namn" ;

eko<<<"EOT"
Mitt namn är "$name". Jag skriver ut $foo->foo.
Nu skriver jag ut ($foo->bar).
Detta bör inte mata ut ett stort "A": \x41
EOT;
?>

Resultatet av att köra detta exempel:

Mitt namn är "$name". Jag skriver ut $foo->foo. Nu skriver jag ut ($foo->bar). Detta bör inte mata ut ett stort "A": \x41

Kommentar:

Till skillnad från heredoc kan nowdoc användas i alla sammanhang med statisk data. Ett typiskt exempel på initiering av klassfält eller konstanter:

Exempel #7 Exempel på användning av statisk data

klass foo(
offentlig $bar =<<<"EOT"
bar
EOT;
}
?>

Kommentar:

nowdoc-stöd lades till i PHP 5.3.0.

Hantera variabler

Om en sträng anges med dubbla citattecken, eller använder heredoc, bearbetas variablerna inuti den.

Det finns två typer av syntax: enkel och komplex. Enkel syntax är enklare och bekvämare. Det gör det möjligt att bearbeta en variabel, ett matrisvärde ( array) eller objektegenskaper ( objekt) med ett minimum av ansträngning.

Komplex syntax kan identifieras av de lockiga klammerparenteserna som omger uttrycket.

Enkel syntax

Om tolken stöter på ett dollartecken ( $ ), fångar den så många tecken som möjligt för att bilda ett giltigt variabelnamn. Om du vill ange slutet på ett namn, omslut variabelnamnet med klammerparenteser.

$juice = "äpple" ;

echo "Han drack lite $juicejuice." . PHP_EOL ;
// fungerar inte, "s" är ett giltigt tecken för ett variabelnamn,
// men vår variabel heter $juice.
echo "Han drack lite juice gjord av $juice." ;
?>

Resultatet av att köra detta exempel:

Han drack lite äppeljuice. Han drack lite juice gjord av .

Ett matriselement ( array) eller objektegenskap ( objekt). I matrisindex finns en avslutande hakparentes ( ] ) markerar slutet på indexdefinitionen. Samma regler gäller för objektegenskaper som för enkla variabler.

Exempel #8 Enkelt syntaxexempel

$juices = array("äpple" , "orange" , "koolaid1" => "lila" );

echo "Han drack lite $juice [0] juice." . PHP_EOL ;
echo "Han drack några $juices [ 1 ] juice." . PHP_EOL ;
echo "Han drack lite $juices [ koolaid1 ] juice." . PHP_EOL ;

klassmänniskor (
public $john = "John Smith" ;
public $jane = "Jane Smith" ;
public $robert = "Robert Paulsen" ;

Public $smith = "Smith" ;
}

$people = nya människor();

echo "$people -> john drack lite $juices [0] juice." . PHP_EOL ;
echo " $people -> john sa sedan hej till $people -> jane ." . PHP_EOL ;
echo "$people -> john "s fru hälsade $people -> robert." . PHP_EOL;
echo " $people -> robert hälsade de två $people -> smederna." ; // Kommer inte att fungera
?>

Resultatet av att köra detta exempel:

Han drack lite äppeljuice. Han drack lite apelsinjuice. Han drack lite lila juice. John Smith drack lite äppeljuice. John Smith sa då hej till Jane Smith. John Smiths fru hälsade Robert Paulsen och Robert Paulsen hälsade de två.

För allt mer komplext, använd komplex syntax.

Komplex (lockig) syntax

Det kallas komplex inte för att det är svårt att förstå, utan för att det tillåter användning av komplexa uttryck.

Varje skalär variabel, matriselement eller objektegenskap som är mappad till en sträng kan representeras i en sträng med den här syntaxen. Skriv bara uttrycket på samma sätt som du skulle göra utanför linjen och linda sedan in det { Och } . Eftersom den { inte kan escapes, denna syntax kommer bara att kännas igen när $ följer direkt { . Använda sig av {\$ att skriva ut {$ . Några illustrativa exempel:

// Visa alla fel
error_reporting(E_ALL);

$great = "bra" ;

// Fungerar inte, utdata: Det här är (bra)
echo "Detta är ($bra)" ;

// Fungerar, utgångar: Det här är bra
echo "Detta är ($bra)" ;
echo "Detta är $(bra)" ;

// Arbetar
eko "Det här torget är brett( $square -> width ) 00 centimeter." ;

// Fungerar, citerade nyckelord fungerar bara med syntax med lockigt klammerparentes
echo "Detta fungerar: ( $arr [ "nyckel" ]) " ;

// Arbetar
echo "Detta fungerar: ( $arr [ 4 ][ 3 ]) " ;

// Detta är ogiltigt av samma anledning som $foo utanför
// rader. Med andra ord, det kommer fortfarande att fungera,
// men eftersom PHP letar efter den konstanta foo först kommer detta att orsaka
// nivåfel E_NOTICE (odefinierad konstant).
eko "Det är inte rätt:( $arr [ foo ][ 3 ]) " ;

// Arbetar. När du använder flerdimensionella arrayer internt
// linjer använder alltid lockiga hängslen
echo "Detta fungerar: ( $arr [ "foo" ][ 3 ]) " ;

// Arbetar.
echo "Detta fungerar: " . $arr [ "foo" ][ 3 ];

eko "Detta fungerar också:($obj -> värden [3]-> namn) " ;

eko "Detta är värdet på variabeln som heter$name : ($( $name )) " ;

eko "Detta är värdet på variabelnamnet som getName() returnerar:($( getName ())) " ;

eko "Detta är värdet på variabeln efter namn som \$object->getName() returnerar:($( $object -> getName ())) " ;

// Fungerar inte, utdata: Det här är vad getName() returnerar: (getName())
eko "Det här är vad getName() returnerar: (getName())";
?>

Det är också möjligt att komma åt objektegenskaper inom strängar med denna syntax.

klass foo(
var $bar = "Jag är bar." ;
}

$foo = new foo();
$bar = "bar" ;
$baz = array("foo" , "bar" , "baz" , "quux" );
echo " ( $foo -> $bar ) \n" ;
echo " ( $foo -> $baz [ 1 ]) \n" ;
?>

Resultatet av att köra detta exempel:

Jag är bar. Jag är bar.

Kommentar:

Funktioner, metodanrop, statiska klassvariabler och klasskonstanter fungerar internt {$} , som börjar med PHP 5. Det angivna värdet kommer dock att behandlas som ett variabelnamn i samma sammanhang som raden där det definieras. Använd enkla lockiga hängslen ( {} ) fungerar inte för att komma åt värdena för funktioner, metoder, klasskonstanter eller statiska klassvariabler.

// Visa alla fel
error_reporting(E_ALL);

klass öl (
const läsk = "rootbeer" ;
public static $ale = "ipa" ;
}

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

// Det här fungerar, utgångar: Jag skulle vilja ha A & W
echo "Jag skulle vilja ha ($( öl :: läsk )) \n" ;

// Det här fungerar också, utgångar: Jag skulle vilja ha Alexander Keiths
echo "Jag skulle vilja ha ($( öl :: $ale )) \n" ;
?>

Få åtkomst till och ändra ett tecken i en sträng

Tecken i strängar kan användas och modifieras genom att ange deras offset från början av strängen, med början på noll, inom hakparenteser efter strängen, till exempel $str . Tänk på en sträng för detta ändamål som en uppsättning tecken. Om du behöver skaffa eller ersätta mer än 1 tecken kan du använda funktionerna substr() Och substr_replace().

Kommentar: Ett tecken i en sträng kan också nås med hängslen, till exempel $str(42) .

Uppmärksamhet

Ett försök att skriva till en offset utanför linjens gränser kommer att fylla strängen med blanksteg upp till den offseten. Icke-heltalstyper kommer att konverteras till heltalstyper. Fel offsettyp kommer att orsaka ett nivåfel E_NOTICE. Att skriva till en negativ offset kommer att orsaka ett nivåfel E_NOTICE, och när den läses kommer den att returnera en tom sträng. Endast det första tecknet i den tilldelade strängen används. Att tilldela en tom sträng tilldelar en nollbyte (NULL).

Uppmärksamhet

Strängar i PHP är internt arrayer av byte. Som ett resultat av detta är åtkomst till eller modifiering av en sträng vid en förskjutning inte säker för flerbytekodning, och bör endast göras med strängar i enkelbytekodningar, som ISO-8859-1.

Exempel #9 Några exempelsträngar

// Hämta det första tecknet i strängen
$str = "Detta är ett test." ;
$först = $str [0 ];

// Hämta det tredje tecknet i strängen
$tredje = $str [2 ];

// Hämta det sista tecknet i strängen
$str = "Detta är fortfarande ett test." ;
$last = $str [strlen ($str ) - 1 ];

// Ändra det sista tecknet på raden
$str = "Titta på havet" ;
$str [ strlen ($str )- 1 ] = "e" ;

?>

Från och med PHP 5.4 måste offset i strängen anges som antingen ett heltal eller en sträng som innehåller siffror, annars kommer en varning att utfärdas. Tidigare offset givet av en sträng som "foo", utan förvarning förvandlades till 0 .

Exempel #10 Skillnader mellan PHP 5.3 och 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" ]));
?>

Resultatet av att köra detta exempel i PHP 5.3:

string(1) "b" bool(true) string(1) "b" bool(true) string(1) "a" bool(true) string(1) "b" bool(true)

Resultatet av att köra detta exempel i PHP 5.4:

string(1) "b" bool(true) Varning: Olaglig strängoffset "1.0" i /tmp/t.php på rad 7 string(1) "b" bool(false) Varning: Olaglig strängoffset "x" i / tmp/t.php på rad 9 string(1) "a" bool(false) string(1) "b" bool(false)

Kommentar:

Försöker komma åt variabler av andra typer (exklusive arrayer eller objekt som implementerar vissa gränssnitt) med eller {} kommer tyst tillbaka NULL.

Kommentar:

PHP 5.5 lade till stöd för åtkomst av tecken i strängliteraler med hjälp av syntaxen eller {} .

Det finns många användbara funktioner för att modifiera strängar.

Grundläggande funktioner beskrivs i avsnittet om strängfunktioner, och för avancerad sökning och ersätt, reguljära uttryck eller Perl-kompatibla reguljära uttrycksfunktioner.

Konvertera till sträng

Värdet kan konverteras till en sträng med hjälp av en cast (sträng), eller funktioner strval(). I uttryck där en sträng krävs sker konverteringen automatiskt. Detta händer när du använder funktioner eko eller skriva ut, eller när värdet på en variabel jämförs med en sträng. Genom att läsa manualens avsnitt om Typer och Typmanipulation blir följande tydligare. se även settype().

Matriser konverteras alltid till strängar "Array", så du kan inte visa innehållet i arrayen ( array), använder sig av eko eller skriva ut för att se vad den innehåller. För att visa ett enskilt element, använd något liknande echo $arr["foo"]. Se nedan för tips om hur du visar/visar allt innehåll.

Objekt i PHP 4 konverterades alltid till en sträng "Objekt". Om du vill visa värdena för ett objekts fält ( objekt) för felsökningsändamål, läs vidare. Om du vill få klassnamnet för det obligatoriska objektet, använd get_class(). Sedan PHP 5 har metoden __toString också blivit tillgänglig.

NULL konverteras alltid till den tomma strängen.

Som du kan se ovan ger direkt omvandling av arrayer, objekt eller resurser till en sträng ingen användbar information om själva värdena förutom deras typer. Ett bättre sätt att mata ut värden för felsökning är att använda funktioner print_r() Och var_dump().

De flesta värden i PHP kan konverteras till en sträng för beständig lagring. Denna metod kallas serialisering och kan göras med hjälp av funktionen serialisera(). Dessutom, om din PHP-installation har WDDX-stöd, är serialisering till en XML-struktur också möjlig.

Konvertera strängar till tal

Om strängen känns igen som ett numeriskt värde, bestäms det resulterande värdet och typen enligt följande.

Om strängen inte innehåller något av tecknen ".", "e" eller "E", och värdet på talet faller inom gränserna för heltal (definierad PHP_INT_MAX), kommer strängen att kännas igen som ett heltal ( heltal). I alla andra fall betraktas det som ett flyttal ( flyta).

Värdet bestäms av början av strängen. Om raden börjar med ett giltigt numeriskt värde kommer det värdet att användas. Annars blir värdet 0 (noll). Ett giltigt numeriskt värde är en eller flera siffror (som kan innehålla en decimalkomma), eventuellt föregås av ett tecken, följt av en valfri exponent. Exponenten är "e" eller "E" följt av en eller flera siffror.

$foo = 1 + "10.5" ; // $foo är en flöte (11,5)
$foo = 1 + "-1.3e3" ; // $foo är en flöte (-1299)
$foo = 1 + "bob-1.3e3" ; // $foo är ett heltal (1)
$foo = 1 + "bob3" ; // $foo är ett heltal (1)
$foo = 1 + "10 små grisar" ; // $foo är ett heltal (11)
$foo = 4 + "10.2 Små grisar" ; // $foo är en flöte (14.2)
$foo = "10.0 grisar" + 1 ; // $foo är flytande (11)
$foo = "10.0 grisar" + 1.0 ; // $foo är flytande (11)
?>

Mer detaljerad information För information om denna konvertering, se avsnittet om strtod(3) i Unix-dokumentationen.

Om du vill testa något av exemplen i det här avsnittet, kopiera och klistra in det och följande rad för att se vad som händer:

echo "\$foo== $foo ; skriv: " . gettype ($foo) . "
\n" ;
?>

Förvänta dig inte att få koden för ett tecken genom att konvertera det till ett heltal (som görs till exempel i C). För att konvertera tecken till deras ASCII-koder och tillbaka, använd funktionerna ord() Och chr().

Implementeringsdetaljer för strängtyp

Strängtyp ( sträng) i PHP implementeras som en array av byte och ett heltal som innehåller längden på bufferten. Den innehåller ingen information om hur man konverterar dessa bytes till tecken, vilket överlåter denna uppgift till programmeraren. Det finns inga begränsningar för innehållet i en sträng, till exempel en byte med ett värde 0 ("NUL" byte) kan placeras var som helst (var dock medveten om att vissa funktioner, som anges i denna manual, inte är "binärsäkra", dvs. de kan skicka strängar till bibliotek som ignorerar data efter NUL -byte).

Denna typ av strängtyp förklarar varför PHP inte har en separat "byte"-typ - strängar spelar den rollen. Funktioner som returnerar icke-textdata – till exempel en godtycklig dataström som läses från ett nätverksuttag – returnerar fortfarande strängar.

Med tanke på det faktum att PHP inte dikterar en specifik kodning för strängar, kan man fråga sig hur strängliteralerna sedan kodas. Till exempel linjen "á" likvärdig "\xE1"(ISO-8859-1), "\xC3\xA1"(UTF-8, normaliseringsform C), "\x61\xCC\x81"(UTF-8, normaliseringsform D) eller någon annan möjlig representation? Svaret är att strängen kommer att kodas som den är skriven i skriptfilen. Således, om skriptet är skrivet i ISO-8859-1-kodning, kommer strängen att kodas i ISO-8859-1, etc. Den här regeln gäller dock inte när Zend Multibyte-läget är aktiverat: i det här fallet kan skriptet skrivas med valfri kodning (antingen uttryckligen specificerad eller automatiskt bestämd), och sedan konverteras till en specifik intern kodning, som sedan kommer att användas för sträng bokstaver. Observera att skriptkodningen (eller intern kodning om Zend Multibyte är aktiverad) har vissa begränsningar: kodningen måste nästan alltid vara en superset av ASCII, såsom UTF-8 eller ISO-8859-1. Observera också att tillståndsberoende kodningar, där samma bytevärden kan användas i det initiala och icke-initiella skifttillståndet, kan orsaka problem.

Naturligtvis, för att vara användbara, måste strängfunktioner göra vissa antaganden om strängens kodning. Tyvärr, bland PHP-funktioner finns det ganska många olika metoder för detta problem:

• Vissa funktioner förutsätter att strängen är kodad i någon enkelbyte-kodning, men de behöver inte tolka byten som specifika tecken för att fungera korrekt. Denna kategori omfattar t.ex. substr(), strpos(), strlen() Och strcmp(). Ett annat sätt att tänka kring dessa funktioner är att de fungerar på minnesbuffertar, d.v.s. de arbetar direkt med bytes och deras offset. offset.
• Andra funktioner förväntar sig att en kodning ska skickas som en parameter, kanske förutsatt att någon standardkodning antas om en kodningsparameter inte specificerats. Denna funktion är
• Slutligen finns det funktioner som förutsätter att en sträng använder en specifik kodning, vanligtvis UTF-8. De flesta funktioner från intl- och PCRE-tilläggen faller här (i det senare fallet, endast när du anger modifieraren u). Även om detta görs med avsikt, funktionen utf8_decode() innebär UTF-8-kodning, och utf8_encode()- ISO-8859-1.

Att skriva korrekta program som fungerar med Unicode innebär i slutändan att man noggrant undviker funktioner som inte fungerar med Unicode och som sannolikt kommer att korrumpera data, och att man istället använder giltiga funktioner, vanligtvis från tilläggen intl och mbstring. Att använda Unicode-kompatibla funktioner är dock en bra början. Oavsett vilka funktioner ett språk tillhandahåller är det nödvändigt att känna till själva Unicode-specifikationen. Till exempel, om ett program antar att det bara finns gemener och versaler i ett språk, så gör det ett stort misstag.

Vilken typ av citattecken ska jag använda för att formatera strängar - apostrof eller klassiska citattecken?

Låt oss titta på skillnaden mellan dubbla och enkla citattecken i PHP, och använd exempel för att ta reda på när du ska använda vilken.

Variabler och escape-sekvenser för specialtecken som finns i strängar omslutna av enkla citattecken bearbetas inte. Strängar omgivna av apostrof bearbetas mycket snabbare av PHP-tolken än liknande strängar omgivna av dubbla citattecken.

Anledningen här är enkel: PHP-tolken kontrollerar dessutom strängar i dubbla citattecken för närvaron av variabler, och om de hittas infogas dess värde i strängen istället för variabelnamnet. Men en rad innesluten i apostrof uppfattas av tolken som vanlig text och PHP genomför inga transformationer på dessa rader. Jag tror att det är klart att bearbetning av strängar i enstaka citattecken kommer att gå snabbare i alla fall.

Låt oss först beskriva hur man definierar en sträng och sedan kontrollera hur mycket snabbare det kommer att gå att bearbeta strängar i enstaka citattecken.

Det enklaste sättet att definiera en sträng är att omsluta den i enkla citattecken ("). För att använda enstaka citattecken inom en sträng med enkla citattecken måste de föregås av ett omvänt snedstreck (\), det vill säga escaped. Om det omvända snedstrecket måste komma före ett enstaka citat eller vara i slutet av raden måste du duplicera det. Om du försöker undkomma något annat tecken, kommer även omvänt snedstreck att skrivas ut.

Här är ett exempel på hur du använder enstaka citattecken:
// Output: Enkel sträng
echo "Enkel sträng";
// Utskrifter: Jag är här
echo "Jag är här";
// Utdata: Detta kommer inte att infoga: \n ny rad
echo "Detta kommer inte att infoga:\nny linje";
// Utdata: Variabeln $example kommer inte att ersättas heller
echo "Variabeln $example kommer inte heller att ersättas"; Om strängen är omgiven av dubbla citattecken ("), känner PHP igen stor kvantitet kontrollsekvenser för specialtecken och ersätter även dess värde istället för variabelnamnet i strängen. Precis som med enkla citattecken, för att använda dubbla citattecken inom en sträng med dubbla citattecken, måste de föregås av ett omvänt snedstreck (\).

Här är ett exempel på hur du använder dubbla citattecken:
// Output: Enkel sträng
echo "Enkel sträng";
// Utgångar: Företag "Snowdrop"
echo "Företag \"Snödroppe\"";
// Utdata: Detta kommer att leda till en ny rad
echo "Detta kommer att bryta till en ny rad \n";
// Output: Variabeln kommer att ersättas
$example = "kommer att ersättas";
echo "Variabel $exempel"; Man bör också komma ihåg att sekvensen "\n" ( ny linje), "\r" (vagnretur) för vanlig text, inte HTML. Så du kommer inte att se ändringar i webbläsaren (endast i källkod sidor).

Låt oss ta reda på hur mycket snabbare enkla citattecken är än dubbla citattecken. För mätningar kommer vi att skriva ett kort testskript, och vi kommer omedelbart att notera att om du testar det själv kommer resultaten, som beror på hårdvaran på din PC eller server, att bli annorlunda.
// Returnera tidsstämpeln i början av loopen
$start = mikrotid(true);
// Skapa en loop för 1 miljon iterationer
för ($i = 0; $i< 1000000; $i++) {
$text = "Här är en teckensträng";
}
// Beräkna tidsåtgången
$tid = (microtime(true) - $start); Resultat: 0,09 sekunder.

Om vi ​​ersätter enkla citattecken med dubbla citattecken:
$text = "Här är en teckensträng"; Resultatet blir 0,10 sekunder.

Som du kan se, när du använder textsträngar, är skillnaden i exekveringstid mycket liten, man kan till och med säga att den inte existerar alls. Det roliga börjar när vi försöker kombinera en sträng och en variabel.
$text = "Här är teckensträngen $i"; eller
$text = $i."Här är en teckensträng"; Resultat ungefär: 0,27 sekunder.

Skillnaden är ganska märkbar. Sammankoppling och dubbla citattecken påverkar tydligt prestandan när variabler läggs till i strängen.

När servern bearbetar koden kontrollerar den allt innehåll i dubbla citattecken för variabler, konstanter och mer. Det tar tid. Och servern bearbetar det som står mellan enstaka citattecken som färdig text och bryr sig inte om vad som finns där. Skillnaden mellan prestanda för enkla och dubbla citattecken är mycket liten, men om du utvecklar ett mycket laddat projekt, är några millisekunder sparade redan en seger.