Strängar

Strängar

En sträng är en serie tecken, där ett tecken är detsamma som en byte. Detta innebär att PHP endast stöder en teckenuppsättning på 256 tecken och därmed inte erbjuder inbyggt stöd för Unicode. Se detaljer om strängtypen.

Notera: På 32-bitars byggen kan en sträng vara så stor som upp till 2 GB (2147483647 byte maximalt)

Syntax

En strängliteral kan specificeras på fyra olika sätt:

• Enkelt citattecken
• Dubbelt citattecken
• Heredoc-syntax
• Nowdoc-syntax

Enkelt Citattecken

Det enklaste sättet att specificera en sträng är att omsluta den i enkla citat (tecknet ').

För att ange ett bokstavligt enkelt citattecken, flykta det med ett omvänt snedstreck (\). För att ange ett bokstavligt omvänt snedstreck, dubbla det (\\). Alla andra instanser av omvänt snedstreck behandlas som ett bokstavligt omvänt snedstreck: detta innebär att andra flyktsekvenser som du kanske är van vid, såsom \r eller \n, kommer att skrivas ut bokstavligt som angivet istället för att ha någon särskild betydelse.

Notera: Till skillnad från dubbelciterade och heredoc-syntaxer, kommer variabler och flyktsekvenser för specialtecken inte att expanderas när de förekommer i enkelt citerade strängar.

echo 'detta är en enkel sträng';

echo 'Du kan också ha inbäddade radbrytningar i
strängar på detta sätt eftersom det är
okej att göra så';

// Utmatningar: Arnold sa en gång: "Jag kommer tillbaka"
echo 'Arnold sa en gång: "Jag kommer tillbaka"';

// Utmatningar: Du raderade C:\*.*?
echo 'Du raderade C:\\*.*?';

// Utmatningar: Det här kommer inte att expandera: \n en ny rad
echo 'Det här kommer inte att expandera: \n en ny rad';

// Utmatningar: Variabler expanderar inte $heller
echo 'Variabler expanderar inte $heller';

Dubbelt Citattecken

Om strängen är omsluten i dubbla citat ("), kommer PHP att tolka följande flyktsekvenser för specialtecken:

Sekvens	Betydelse
\n	radmatning (LF eller 0x0A (10) i ASCII)
\r	vagnretur (CR eller 0x0D (13) i ASCII)
\t	horisontell tabb (HT eller 0x09 (9) i ASCII)
\v	vertikal tabb (VT eller 0x0B (11) i ASCII)
\e	escape (ESC eller 0x1B (27) i ASCII)
\f	sidmatning (FF eller 0x0C (12) i ASCII)
\\	omvänt snedstreck
\$	dollartecken
\"	dubbelt citattecken
\[0-7]{1,3}	Oktal: sekvensen av tecken som matchar det reguljära uttrycket [0-7]{1,3} är en tecken i oktal notation (t.ex. "\101" === "A"), som tyst överflödar för att passa i en byte (t.ex. "\400" === "\000")
\x[0-9A-Fa-f]{1,2}	Hexadecimal: sekvensen av tecken som matchar det reguljära uttrycket [0-9A-Fa-f]{1,2} är en tecken i hexadecimal notation (t.ex. "\x41" === "A")
\u{[0-9A-Fa-f]+}	Unicode: sekvensen av tecken som matchar det reguljära uttrycket [0-9A-Fa-f]+ är en Unicode kodpunkt, som kommer att skrivas ut till strängen som den kodpunktens UTF-8 representation. Klammern är obligatorisk i sekvensen. T.ex. "\u{41}" === "A"

Som i enkelt citerade strängar, om du flyktar någon annan karaktär kommer omvänt snedstreck att skrivas ut också.

Den viktigaste egenskapen hos dubbelciterade strängar är det faktum att variabelnamn kommer att expanderas. Se strängtolkning för detaljer.

Heredoc

Ett tredje sätt att avgränsa strängar är heredoc-syntaxen: <<<. Efter denna operator anges en identifierare, följt av en ny rad. Strängen följer sedan, och sedan samma identifierare igen för att stänga citatet.

Identifieraren för stängning kan vara indragen med mellanslag eller tabb, i så fall kommer indraget att tas bort från alla rader i dok-strängen. Före PHP 7.3.0 måste stängningsidentifieraren börja i den första kolumnen på raden.

Identifieraren för stängning måste också följa samma namnregler som någon annan etikett i PHP: den måste innehålla endast alfanumeriska tecken och understreck, och måste börja med en icke-sifferkaraktär eller understreck.

Exempel #1 Grundläggande Heredoc-exempel från och med PHP 7.3.0

// ingen indragning
echo <<<END
      a
     b
    c
\n
END;

// 4 mellanslag i indragning
echo <<<END
      a
     b
    c
    END;

Utdata från ovanstående exempel i PHP 7.3:

     a
    b
   c

 a
b

c Om stängningsidentifieraren är indragen mer än några rader i kroppen, kommer ett ParseError att kastas:

Exempel #2 Stängningsidentifieraren får inte vara indragen längre än några rader i kroppen

echo <<<END
  a
 b
c
   END;

Utdata från ovanstående exempel i PHP 7.3:

PHP Parse error: Ogiltig kropp indragning nivå (förväntar sig en indragningsnivå på minst 3) i example.php på rad 4 Om stängningsidentifieraren är indragen kan flikar också användas, men flikar och mellanslag får inte blandas när det gäller indragningen av stängningsidentifieraren och indragningen av kroppen (upp till stängningsidentifieraren). I något av dessa fall kommer ett ParseError att kastas. Dessa blankstegsbegränsningar har inkluderats eftersom att blanda flikar och mellanslag för indragning är skadligt för läsbarheten.

Exempel #3 Olika indrag för kropp (mellanslag) stängningsidentifierare

// All följande kod fungerar inte.

// olika indrag för kropp (mellanslag) slutmarkör (flikar)
{
    echo <<<END
     a
        END;
}

// blandar mellanslag och flikar i kroppen
{
    echo <<<END
        a
     END;
}

// blandar mellanslag och flikar i slutmarkören
{
    echo <<<END
          a
         END;
}

Utdata från ovanstående exempel i PHP 7.3:

PHP Parse error: Ogiltig indragning - flikar och mellanslag kan inte blandas i example.php rad 8 Stängningsidentifieraren för kroppsträngen behöver inte följas av ett semikolon eller en ny rad. Till exempel är följande kod tillåten från och med PHP 7.3.0:

Exempel #4 Fortsätt ett uttryck efter en stängningsidentifierare

$values = [<<<END
a
  b
    c
END, 'd e f'];
var_dump($values);

Utdata från ovanstående exempel i PHP 7.3:

array(2) {

 [0] =>
 string(11) "a
 b
   c"
 [1] =>
 string(5) "d e f"

} Varning Om stängningsidentifieraren hittades i början av en rad, oavsett om den var en del av ett annat ord, kan den betraktas som stängningsidentifieraren och orsaka ett ParseError.

Exempel #5 Stängningsidentifierare i kroppen av strängen tenderar att orsaka ParseError

$values = [<<<END
a
b
END ING
END, 'd e f'];

Utdata från ovanstående exempel i PHP 7.3:

PHP Parse error: syntaxfel, oväntad identifierare "ING", förväntar sig "]" i example.php på rad 6 För att undvika detta problem är det säkert att följa den enkla regeln: välj inte som stängningsidentifierare om den förekommer i kroppen av texten.

Varning Före PHP 7.3.0 är det mycket viktigt att notera att raden med stängningsidentifieraren inte får innehålla några andra tecken, utom ett semikolon (;). Det innebär särskilt att identifieraren inte får vara indragen, och det får inte vara några mellanslag eller flikar före eller efter semikolonet. Det är också viktigt att inse att det första tecknet före stängningsidentifieraren måste vara en ny rad som definieras av det lokala operativsystemet. Detta är \n på UNIX-system, inklusive macOS. Stängningsavgränsaren måste också följas av en ny rad.

Om denna regel bryts och stängningsidentifieraren inte är "ren", kommer den inte att betraktas som en stängningsidentifierare, och PHP kommer att fortsätta leta efter en. Om en korrekt stängningsidentifierare inte hittas innan slutet av den nuvarande filen kommer ett parsefel att resultera på sista raden.

Exempel #6 Ogiltigt exempel, före PHP 7.3.0

class foo {
    public $bar = <<<EOT
bar
    EOT;
}
// Identifieraren får inte vara indragen

Exempel #7 Giltigt exempel, även före PHP 7.3.0

class foo {
    public $bar = <<<EOT
bar
EOT;
}

Heredocs som innehåller variabler kan inte användas för att initiera klass egenskaper.

Heredoc-text beter sig precis som en dubbelciterad sträng, utan dubbelcitat. Detta innebär att citat i en heredoc inte behöver flyktas, men de ovan listade flyktkoderna kan fortfarande användas. Variabler expanderas, men samma omsorg måste tas när man uttrycker komplexa variabler inuti en heredoc som med strängar.

Exempel #8 Heredoc-strängciteringsexempel

$str = <<<EOD
Exempel på sträng
som sträcker sig över flera rader
med användning av heredoc-syntax.
EOD;

/* Mer komplicerat exempel, med variabler. */
class foo
{
    var $foo;
    var $bar;

    function __construct()
    {
        $this->foo = 'Foo';
        $this->bar = array('Bar1', 'Bar2', 'Bar3');
    }
}

$foo = new foo();
$name = 'MittNamn';

echo <<<EOT
Mitt namn är "$name". Jag skriver ut lite $foo->foo.
Nu skriver jag ut lite {$foo->bar[1]}.
Detta bör skriva ut en stor 'A': \x41
EOT;

Ovanstående exempel kommer att ge utdata:

Mitt namn är "MittNamn". Jag skriver ut lite Foo. Nu skriver jag ut lite Bar2. Detta bör skriva ut en stor 'A': A Det är också möjligt att använda heredoc-syntax för att skicka data till funktionsargument:

Exempel #9 Heredoc i argument exempel

var_dump(array(<<<EOD
foobar!
EOD
));

Det är möjligt att initiera statiska variabler och klass egenskaper/konstanter med hjälp av heredoc-syntaxen:

Exempel #10 Användning av Heredoc för att initiera statiska värden

// Statiska variabler
function foo()
{
    static $bar = <<<LABEL
Ingenting här...
LABEL;
}

// Klass egenskaper/konstanter
class foo
{
    const BAR = <<<FOOBAR
Konstant exempel
FOOBAR;

    public $baz = <<<FOOBAR
Egenskap exempel
FOOBAR;
}

Öppningsidentifieraren för Heredoc kan valfritt vara omsluten i dubbla citat:

Exempel #11 Använda dubbla citat i Heredoc

echo <<<"FOOBAR"
Hej Världen!
FOOBAR;

Nowdoc

Nowdocs är till enkelt citerade strängar vad heredocs är till dubbelciterade strängar. En nowdoc specificeras på ett liknande sätt som en heredoc, men ingen tolkning görs inuti en nowdoc. Konstruktionen är idealisk för att bädda in PHP-kod eller andra stora textblock utan behov av att flykta. Den delar vissa funktioner gemensamt med SGML <![CDATA[ ]]> konstruktionen, i det att den förklarar ett textblock som inte är för tolkning.

En nowdoc identifieras med samma <<< sekvens som används för heredocs, men identifieraren som följer är omsluten i enkla citat, t.ex. <<<'EOT'. Alla regler för heredoc-identifierare gäller också för nowdoc-identifierare, särskilt de som gäller utseendet på stängningsidentifieraren.

Exempel #12 Nowdoc-strängciteringsexempel

echo <<<'EOD'
Exempel på sträng som sträcker sig över flera rader
med användning av nowdoc-syntax. Omvända snedstreck behandlas alltid bokstavligt,
t.ex. \\ och \'.
EOD;

Ovanstående exempel kommer att ge utdata:

Exempel på sträng som sträcker sig över flera rader med användning av nowdoc-syntax. Omvända snedstreck behandlas alltid bokstavligt, t.ex. \\ och \'. Exempel #13 Nowdoc-strängciteringsexempel med variabler

class foo
{
    public $foo;
    public $bar;

    function __construct()
    {
        $this->foo = 'Foo';
        $this->bar = array('Bar1', 'Bar2', 'Bar3');
    }
}

$foo = new foo();
$name = 'MittNamn';

echo <<<'EOT'
Mitt namn är "$name". Jag skriver ut lite $foo->foo.
Nu skriver jag ut lite {$foo->bar[1]}.
Detta bör inte skriva ut en stor 'A': \x41
EOT;

Ovanstående exempel kommer att ge utdata:

Mitt namn är "$name". Jag skriver ut lite $foo->foo. Nu skriver jag ut lite {$foo->bar[1]}. Detta bör inte skriva ut en stor 'A': \x41 Exempel #14 Statisk data exempel

class foo {
    public $bar = <<<'EOT'
bar
EOT;
}

Variabeltolkning

När en sträng specificeras i dubbla citat eller med heredoc, tolkas variabler inuti den.

Det finns två typer av syntax: en enkel och en komplex. Den enkla syntaxen är den vanligaste och bekvämaste. Den erbjuder ett sätt att bädda in en variabel, ett arrayvärde eller en objektegenskap i en sträng med minimal ansträngning.

Den komplexa syntaxen kan kännas igen genom de krulliga parenteserna som omsluter uttrycket.

Enkel syntax Om ett dollartecken ($) stöter på kommer tolkaren att girigt ta så många tecken som möjligt för att bilda ett giltigt variabelnamn. Omslut variabelnamnet i krulliga parenteser för att tydligt ange slutet på namnet.

$juice = "äpple";

echo "Han drack lite $juice juice." . PHP_EOL;

// Oavsiktligt. "s" är en giltig karaktär för ett variabelnamn, så detta hänvisar till $juices, inte $juice.
echo "Han drack lite juice gjord av $juices." . PHP_EOL;

// Anger tydligt slutet på variabelnamnet genom att omsluta referensen i parenteser.
echo "Han drack lite juice gjord av {$juice}s.";

Ovanstående exempel kommer att ge utdata:

Han drack lite äpplejuice. Han drack lite juice gjord av . Han drack lite juice gjord av äpplen. På samma sätt kan ett arrayindex eller en objektegenskap tolkas. Med arrayindex markerar den avslutande hakparentesen (]) slutet på indexet. Samma regler gäller för objektegenskaper som för enkla variabler.

Exempel #15 Enkel syntax exempel

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

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

class people {
    public $john = "John Smith";
    public $jane = "Jane Smith";
    public $robert = "Robert Paulsen";

    public $smith = "Smith";
}

$people = new people();

echo "$people->john drack lite $juices[0] juice.".PHP_EOL;
echo "$people->john sade sedan hej till $people->jane.".PHP_EOL;
echo "$people->johns fru hälsade på $people->robert.".PHP_EOL;
echo "$people->robert hälsade på de två $people->smiths."; // Fungerar inte

Ovanstående exempel kommer att ge utdata:

Han drack lite äpplejuice. Han drack lite apelsinjuice. Han drack lite lila juice. John Smith drack lite äpplejuice. John Smith sade sedan hej till Jane Smith. John Smiths fru hälsade på Robert Paulsen. Robert Paulsen hälsade på de två . Från och med PHP 7.1.0 stöds också negativa numeriska index.

Exempel #16 Negativa numeriska index

$string = 'sträng';
echo "Tecknet vid index -2 är $string[-2].", PHP_EOL;
$string[-3] = 'o';
echo "Att ändra tecknet vid index -3 till o ger $string.", PHP_EOL;

Ovanstående exempel kommer att ge utdata:

Tecknet vid index -2 är n. Att ändra tecknet vid index -3 till o ger strong. För något mer komplext bör du använda den komplexa syntaxen.

Komplex (krullig) syntax Detta kallas inte komplext eftersom syntaxen är komplex, utan för att det tillåter användning av komplexa uttryck.

Alla skalära variabler, arrayelement eller objektegenskaper med en strängrepresentation kan inkluderas via denna syntax. Uttrycket skrivs på samma sätt som det skulle visas utanför strängen och sedan omsluts i { och }. Eftersom { inte kan flyktas, kommer denna syntax endast att kännas igen när $ omedelbart följer {. Använd {\$ för att få en bokstavlig {$. Några exempel för att göra det klart:

// Visa alla fel
error_reporting(E_ALL);

$great = 'fantastisk';

// Fungerar inte, ger utdata: Det här är { fantastisk}
echo "Det här är { $great}";

// Fungerar, ger utdata: Det här är fantastisk
echo "Det här är {$great}";

// Fungerar
echo "Den här kvadraten är {$square->width}00 centimeter bred.";


// Fungerar, citerade nycklar fungerar endast med krullig parentessyntax
echo "Det här fungerar: {$arr['key']}";


// Fungerar
echo "Det här fungerar: {$arr[4][3]}";

// Det här är fel av samma anledning som $foo[bar] är fel utanför en sträng.
// PHP letar först efter en konstant med namnet foo och ger ett fel om den inte hittas.
// Om konstanten hittas, skulle dess värde (och inte 'foo' själv) användas
// för arrayindexet.
echo "Det här är fel: {$arr[foo][3]}";

// Fungerar. När du använder flerdimensionella arrayer, använd alltid parenteser runt arrayer
// när de är inne i strängar
echo "Det här fungerar: {$arr['foo'][3]}";

// Fungerar.
echo "Det här fungerar: " . $arr['foo'][3];

echo "Det här fungerar också: {$obj->values[3]->name}";

echo "Det här är värdet på variabeln som heter $name: {${$name}}";

echo "Det här är värdet på variabeln som heter av returvärdet från getName(): {${getName()}}";

echo "Det här är värdet på variabeln som heter av returvärdet från \$object->getName(): {${$object->getName()}}";

// Fungerar inte, ger utdata: Det här är returvärdet från getName(): {getName()}
echo "Det här är returvärdet från getName(): {getName()}";

// Fungerar inte, ger utdata: C:\mapp\{fantastisk}.txt
echo "C:\mapp\{$great}.txt"
// Fungerar, ger utdata: C:\mapp\fantastisk.txt
echo "C:\\mapp\\{$great}.txt"

Det är också möjligt att komma åt klass egenskaper med hjälp av variabler inuti strängar med hjälp av denna syntax.

class 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";

Ovanstående exempel kommer att ge utdata:

Jag är bar. Jag är bar. Notera:

Värdet som nås från funktioner, metodanrop, statiska klassvariabler och klasskonstanter inuti {$} kommer att tolkas som namnet på en variabel i den omfattning där strängen är definierad. Användning av enkla krulliga parenteser ({}) fungerar inte för att komma åt returvärden från funktioner eller metoder eller värdena på klasskonstanter eller statiska klassvariabler.

// Visa alla fel.
error_reporting(E_ALL);

class beers {
    const softdrink = 'rootbeer';
    public static $ale = 'ipa';
}

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

// Det här fungerar; ger utdata: Jag skulle vilja ha en A & W
echo "Jag skulle vilja ha en {${beers::softdrink}}\n";

// Det här fungerar också; ger utdata: Jag skulle vilja ha en Alexander Keith's
echo "Jag skulle vilja ha en {${beers::$ale}}\n";

Åtkomst och modifiering av strängar per tecken

Tecken inuti strängar kan nås och modifieras genom att ange det nollbaserade offsetet för önskat tecken efter strängen med hjälp av fyrkantiga hakparenteser, som i $str[42]. Tänk på en sträng som en array av tecken för detta ändamål. Funktionerna substr() och substr_replace() kan användas när du vill extrahera eller ersätta mer än 1 tecken.

Notera: Från och med PHP 7.1.0 stöds också negativa strängindex. Dessa specificerar offsetet från slutet av strängen. Tidigare gav negativa index E_NOTICE för läsning (vilket resulterade i en tom sträng) och E_WARNING för skrivning (lämnar strängen oförändrad).

Notera: Före PHP 8.0.0 kunde strängar också nås med hjälp av klammerparenteser, som i $str{42}, i samma syfte. Denna krulliga parentessyntax blev föråldrad från och med PHP 7.4.0 och stöds inte längre från och med PHP 8.0.0.

Varning Att skriva till ett index utanför intervallet fyller strängen med mellanslag. Icke-heltalstyper konverteras till heltal. Otillåten offsettyp ger E_WARNING. Endast det första tecknet i en tilldelad sträng används. Från och med PHP 7.1.0 leder tilldelning av en tom sträng till ett fatalt fel. Tidigare tilldelades en NULL-byte.

Varning Internt är PHP-strängar byte-arrayer. Som ett resultat är åtkomst eller modifiering av en sträng med hjälp av hakparenteser inte flerbytesäker och bör endast göras med strängar som är i en encodingskodning som ISO-8859-1.

Notera: Från och med PHP 7.1.0 kastar tillämpning av den tomma indexoperatorn på en tom sträng ett fatalt fel. Tidigare omvandlades den tomma strängen tyst till en array.

Exempel #17 Några strängexempel

// Hämta det första tecknet i en sträng
$str = 'Det här är ett test.';
$first = $str[0];

// Hämta det tredje tecknet i en sträng
$third = $str[2];

// Hämta det sista tecknet i en sträng.
$str = 'Det här är fortfarande ett test.';
$last = $str[strlen($str)-1];

// Modifiera det sista tecknet i en sträng
$str = 'Titta på havet';
$str[strlen($str)-1] = 'e';

Strängindex måste antingen vara heltal eller heltalsliknande strängar, annars kommer en varning att kastas.

Exempel #18 Exempel på olagliga strängindex

$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']));

Ovanstående exempel kommer att ge utdata:

string(1) "b" bool(true)

Varning: Olagligt strängindex '1.0' i /tmp/t.php på rad 7 string(1) "b" bool(false)

Varning: Olagligt strängindex 'x' i /tmp/t.php på rad 9 string(1) "a" bool(false) string(1) "b" bool(false) Notera:

Åtkomst av variabler av andra typer (inte inklusive arrayer eller objekt som implementerar lämpliga gränssnitt) med [] eller {} ger tyst null tillbaka.

Notera:

Tecken inuti strängliteraler kan nås med [] eller {}.

Notera:

Åtkomst av tecken inuti strängliteraler med hjälp av {}-syntaxen har blivit föråldrad i PHP 7.4. Detta har tagits bort i PHP 8.0.

Användbara funktioner och operatorer

Strängar kan sammanfogas med hjälp av '.' (punkt) operatorn. Notera att '+' (additions) operatorn inte kommer att fungera för detta. Se String-operatörer för mer information.

Det finns ett antal användbara funktioner för strängmanipulation.

Se avsnittet om strängfunktioner för allmänna funktioner och Perl-kompatibla reguljära uttrycksfunktioner för avancerad sök- och ersättningsfunktionalitet.

Det finns också funktioner för URL-strängar och funktioner för att kryptera/avkryptera strängar (Sodium och Hash).

Se också funktionerna för teckentypen.

Konvertering till sträng

Ett värde kan konverteras till en sträng med hjälp av (string) cast eller strval()-funktionen. Strängkonvertering görs automatiskt i samband med ett uttryck där en sträng behövs. Detta sker när echo- eller print-funktionerna används, eller när en variabel jämförs med en sträng. Avsnitten om typer och typjonglering kommer att göra detta tydligare. Se också settype()-funktionen.

Ett boolskt true-värde konverteras till strängen "1". Ett boolskt false-värde konverteras till "" (den tomma strängen). Detta möjliggör konvertering fram och tillbaka mellan bool- och strängvärden.

Ett heltal eller flyttal konverteras till en sträng som representerar talet textuellt (inklusive exponentdelen för flyttal). Flyttal kan konverteras med exponentiell notation (4.1E+6).

Notera:

Från och med PHP 8.0.0 är decimaltecken alltid en punkt ("."). Före PHP 8.0.0 definierades decimaltecknet i skriptets lokalinställning (kategori LC_NUMERIC). Se setlocale()-funktionen.

Arrayer konverteras alltid till strängen "Array"; på grund av detta kan echo och print inte själva visa innehållet i en array. För att visa ett enskilt element, använd en konstruktion som echo $arr['foo']. Se nedan för tips om hur man visar hela innehållet.

För att konvertera objekt till strängar måste den magiska metoden __toString användas.

Resurser konverteras alltid till strängar med strukturen "Resource id #1", där 1 är resursnumret som tilldelats resursen av PHP vid körning. Medan den exakta strukturen för denna sträng inte bör förlitas på och är föremål för förändring, kommer den alltid att vara unik för en given resurs under livslängden för ett skript som körs (dvs. en webbförfrågan eller CLI-process) och kommer inte att återanvändas. För att få en resurstyp, använd get_resource_type()-funktionen.

null konverteras alltid till en tom sträng.

Som nämnts ovan ger direkt konvertering av en array, ett objekt eller en resurs till en sträng inte någon användbar information om värdet utöver dess typ. Se funktionerna print_r() och var_dump() för mer effektiva sätt att inspektera innehållet i dessa typer.

De flesta PHP-värden kan också konverteras till strängar för permanent lagring. Denna metod kallas serialisering och utförs av serialize()-funktionen.

Detaljer om strängtypen

Strängen i PHP implementeras som en array av byte och ett heltal som anger längden på bufferten. Den har ingen information om hur dessa byte översätts till tecken, vilket lämnar den uppgiften till programmeraren. Det finns inga begränsningar för vilka värden strängen kan bestå av; särskilt är byte med värdet 0 (“NUL-byte”) tillåtna var som helst i strängen (dock kan några funktioner, som sagt i denna manual att inte vara “binärsäkra”, överlämna strängarna till bibliotek som ignorerar data efter en NUL-byte.)

Denna natur av strängtypen förklarar varför det inte finns en separat “byte”-typ i PHP – strängar tar denna roll. Funktioner som inte returnerar textuell data – till exempel godtycklig data läst från ett nätverksuttag – kommer fortfarande att returnera strängar.

Med tanke på att PHP inte dikterar en specifik kodning för strängar, kan man undra hur strängliteraler är kodade. Till exempel, är strängen "á" ekvivalent med "\xE1" (ISO-8859-1), "\xC3\xA1" (UTF-8, C-form), "\x61\xCC\x81" (UTF-8, D-form) eller någon annan möjlig representation? Svaret är att strängen kommer att kodas på det sätt som den är kodad i skriptfilen. Alltså, om skriptet är skrivet i ISO-8859-1, kommer strängen att kodas i ISO-8859-1 och så vidare. Detta gäller dock inte om Zend Multibyte är aktiverat; i så fall kan skriptet vara skrivet i en godtycklig kodning (som är explicit deklarerad eller upptäckt) och sedan konverteras till en viss intern kodning, som då är den kodning som kommer att användas för strängliteralerna. Notera att det finns vissa begränsningar för kodningen av skriptet (eller den interna kodningen, om Zend Multibyte är aktiverat) – detta innebär nästan alltid att denna kodning bör vara en kompatibel superset av ASCII, såsom UTF-8 eller ISO-8859-1. Notera dock att tillståndsbaserade kodningar där samma bytevärden kan användas i initiala och icke-initiala skiftlägen kan vara problematiska.

Självklart, för att vara användbara, måste funktioner som arbetar med text kanske göra vissa antaganden om hur strängen är kodad. Tyvärr finns det stor variation i denna fråga i PHP:s funktioner:

Vissa funktioner antar att strängen är kodad i någon (valfri) encodingskodning, men de behöver inte tolka dessa byte som specifika tecken. Detta är fallet med till exempel substr(), strpos(), strlen() eller strcmp(). Ett annat sätt att tänka på dessa funktioner är att de fungerar med minnesbuffertar, dvs. de arbetar med byte och byte-offset. Andra funktioner får kodningen av strängen, möjligen antar de också en standard om ingen sådan information ges. Detta är fallet med htmlentities() och majoriteten av funktionerna i mbstring-tillägget. Andra använder den aktuella lokalinställningen (se setlocale()), men arbetar byte-för-byte. Slutligen kan de bara anta att strängen använder en specifik kodning, vanligtvis UTF-8. Detta är fallet med de flesta funktionerna i intl-tillägget och i PCRE-tillägget (i det senare fallet, endast när u-modifieraren används). I slutändan betyder detta att skriva korrekta program med Unicode beror på att noggrant undvika funktioner som inte kommer att fungera och som mest troligt kommer att förstöra data och istället använda de funktioner som beter sig korrekt, vanligtvis från intl- och mbstring-tilläggen. Att använda funktioner som kan hantera Unicode-kodningar är dock bara början. Oavsett vilka funktioner språket tillhandahåller är det avgörande att känna till Unicode-specifikationen. Till exempel gör ett program som antar att det bara finns versaler och gemener ett felaktigt antagande.