Php doble krøllete seler. Konseptet med operatørbraketter

For strenginterpolasjon. Fra manualen:

Kompleks (krøllet) syntaks

Det kalles ikke komplekst fordi syntaksen er kompleks og derfor gir rom for komplekse uttrykk.

Enhver skalarvariabel, matriseelement eller objektegenskap med en strengrepresentasjon kan inkluderes gjennom denne syntaksen. Bare skriv uttrykket som du ville gjort utenfor strengen, og pakk det deretter inn i ( og ) . Siden ( ikke kan escapes, vil denne syntaksen bare gjenkjennes når $ følger ( . bruk (\$ for å få den bokstavelige ($ . Noen eksempler for å gjøre det klart):

width)00 centimeter bred."; // Fungerer, angitte taster fungerer bare ved å bruke det krøllete klammeparentes syntaks-ekkoet "This works: ($arr["key"])"; // Works echo "This works: ($arr)" ; // Dette er feil av samme grunn som $foo er feil utenfor en streng. // Med andre ord vil det fortsatt fungere, men bare fordi PHP først ser etter en // konstant kalt foo; en feil på nivå E_NOTICE ( undefined constant) vil bli // kastet. echo "Dette er feil: ($arr)"; // Fungerer. Når du bruker flerdimensjonale arrays, bruk alltid klammeparenteser rundt arrays // når innsiden av strenger echo "Dette fungerer: ($ arr["foo"])"; // Fungerer. echo "Dette fungerer: " . $arr["foo"]; echo "Dette fungerer også: ($obj->values->name)"; echo "Dette er verdien av varen kalt $name: ($($name))"; echo "Dette er verdien av varen navngitt av returverdien til getName(): ($(getName()))"; echo "This er verdien til varen navngitt av returverdien til \$objekt->getName(): ($($object->getName()))"; // Vil ikke fungere, utganger: Dette er returverdien til getName(): (getName()) echo "Dette er returverdien til getName(): (getName())"; ?>

Ofte er ikke denne syntaksen nødvendig. For eksempel dette:

$a = "abcd"; $out = "$a $a"; // "abcd abcd";

oppfører seg akkurat slik:

$out = "($a) ($a)"; // samme

Dermed er ikke krøllete tannregulering nødvendig. Men dette:

$out = "$aefgh";

vil, avhengig av feilnivået ditt, enten ikke fungere eller skape en feil fordi det ikke er noen variabel kalt $aefgh , så du må gjøre:

$out = "$(a)efgh"; // eller $out = "($a)efgh";

$GLOBALS variabel. En assosiativ matrise som inneholder referanser til alle skriptets globale omfangsvariabler som er definert for øyeblikket. Variablenavn er matrisenøkler.

For å erklære en global variabel, plasser den i $GLOBALS-matrisen

$GLOBALS["testkey2"]="testverdi2";

Du kan vise alle verdiene til $GLOBALS matrisevariablene ved å bruke print_r($GLOBALS); eller slik:

Foreach ($GLOBALS som $key=>$value) ekko "GLOBALS[".$key."] == ".$value."
";

$_SERVER variabel.

$_REQUEST variabel- en assosiativ matrise (matrise), som som standard inneholder dataene til variablene $_GET, $_POST og $_COOKIE. Variabler i $_REQUEST-matrisen sendes til skriptet ved hjelp av metodene GET, POST eller COOKIE, så de kan ikke stoles på fordi de kan ha blitt endret av en ekstern bruker. Deres tilstedeværelse og rekkefølgen data legges til i de tilsvarende matrisene bestemmes av variables_order-direktivet (GPCS er angitt som standard).

$_SESSION variabel

$_ENV variabel. Fylles ut hvis skriptet ble startet fra kommandolinjen. $_SERVER-matrisen vil inneholde alle variablene fra $_ENV-matrisen.

$http_response_header variabel

Kommentar: I PHP 7.0.0 på 64-biters plattformer er det ingen oppnåelige grenser for linjelengde; på 32-bits systemer og i tidligere versjoner av PHP kan ikke linjene være større enn 2 GB (2147483647 byte).

Syntaks

En streng kan defineres på fire forskjellige måter:

• enkelt sitater
• doble anførselstegn
• nowdoc-syntaks(siden PHP 5.3.0)

Enkelte sitater

Den enkleste måten å definere en streng på er å sette den i enkle anførselstegn (symbolet " ).

For å bruke et enkelt anførselstegn inne i en streng, unnslipp det med en omvendt skråstrek ( \ ). Hvis du trenger å skrive selve skråstreken, dupliser den ( \\ ). All annen bruk av omvendt skråstrek vil bli tolket som vanlige tegn: dette betyr at hvis du prøver å bruke andre escape-sekvenser som f.eks. \r eller \n, vil de sendes ut som de er i stedet for spesiell oppførsel.

ekko "dette er en enkel streng";

ekko "Du kan også sette inn i linjer
nylinjekarakter som dette,
Dette er greit";

// Utganger: Arnold sa en gang: "I'll be back"
ekko "En dag sa Arnold: 'Jeg kommer tilbake.'';

Ekko "Har du slettet C:\\*.*?";

// Utganger: Slettet du C:\*.*?
echo "Har du slettet C:\*.*?" ;

// Utganger: Dette vil ikke bli utvidet: \n ny linje
ekko "Dette vil ikke bli utvidet: \n nylinje";

// Utdata: variablene $expand og $either utvides ikke
ekko "$expand- og $either-variablene utvides ikke";
?>

Doble anførselstegn

Hvis strengen er omsluttet av doble anførselstegn ("), gjenkjenner PHP følgende escape-sekvenser for spesialtegn:

Escape-sekvenser

Etterfølge	Betydning
\n	ny linje (LF eller 0x0A (10) i ASCII)
\r	vognretur (CR eller 0x0D (13) i ASCII)
\t	horisontal fane (HT eller 0x09 (9) i ASCII)
\v	vertikal fane (VT eller 0x0B (11) i ASCII) (siden PHP 5.2.5)
\e	escape-tegn (ESC eller 0x1B (27) i ASCII) (siden PHP 5.4.4)
\f	sidefeed (FF eller 0x0C(12) i ASCII) (siden PHP 5.2.5)
\\	skråstrek
\$	dollar tegn
\"	dobbelt anførselstegn
\{1,3}	en sekvens av tegn som samsvarer med et regulært uttrykk for et oktalt tegn som stille flyter over for å passe inn i en byte (dvs. "\400" === "\000")
\x(1,2)	sekvens av tegn som tilsvarer det regulære uttrykket til et tegn i heksadesimal notasjon
\u(+)	en sekvens av tegn som samsvarer med et regulært Unicode-karakteruttrykk som tilordnes en streng i UTF-8-representasjon (lagt til i PHP 7.0.0)

Som med en streng omsluttet av enkle anførselstegn, vil escape-tegn også gi ut selve escape-tegnet. Før PHP 5.1.1, skråstrek inn \($var) ble ikke publisert.

Heredoc

Den tredje måten å definere strenger på er å bruke heredoc-syntaks: <<< . Etter denne operatoren må du spesifisere en identifikator, deretter en linjemating. Etter dette kommer selve linjen, og deretter den samme identifikatoren, som lukker innsettingen.

Linje må start med en avsluttende identifikator, dvs. den må vises i den første kolonnen i raden. I tillegg må identifikatoren følge de samme navnereglene som alle andre tagger i PHP: inneholder kun alfanumeriske tegn og et understrek, og må ikke starte med et tall (understrek er tillatt).

Merk følgende

Det er veldig viktig å merke seg at den avsluttende identifikasjonslinjen ikke må inneholde andre tegn unntatt semikolon ( ; ). Dette betyr at id skal ikke rykkes inn og at det ikke kan være mellomrom eller tabulatorer før eller etter semikolon. Det er også viktig å forstå at det første tegnet før den avsluttende identifikatoren må være et linjeskifttegn som definert av operativsystemet ditt. For eksempel, på UNIX-systemer, inkludert macOS, er dette \n. En ny linje må også begynne umiddelbart etter den avsluttende identifikatoren.

Hvis denne regelen brytes og den avsluttende identifikatoren ikke er "ren", anses den avsluttende identifikatoren som mangler og PHP vil fortsette å lete etter den videre. Hvis i dette tilfellet den riktige avsluttende identifikatoren aldri blir funnet, vil det forårsake en parsefeil med linjenummeret på slutten av skriptet.

Eksempel #1 Eksempel på feil syntaks

klasse foo (
offentlig $bar =<<bar
EOT;
// innrykk før den avsluttende identifikatoren er ikke tillatt
}
?>

Eksempel #2 Eksempel på korrekt syntaks

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

Heredoc kan ikke brukes til å initialisere klassefelt. Fra og med PHP 5.3 gjelder denne begrensningen kun for heredocs som inneholder variabler.

Heredoc-tekst oppfører seg på samme måte som en streng i doble anførselstegn, uten å ha dem. Dette betyr at du ikke trenger å unnslippe sitater i heredoc, men du kan fortsatt bruke escape-sekvensene ovenfor. Variabler behandles, men du må være like forsiktig når du bruker komplekse variabler i heredoc som når du arbeider med strenger.

Eksempel #3 Heredoc-strengdefinisjonseksempel

$str =<<Eksempellinje,
spenner over flere linjer,
ved hjelp av heredoc-syntaks.
EOD;

Klasse foo
{
var $foo ;
var $bar ;

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

$foo = new foo();
$name = "Navn" ;

ekko<<Mitt navn er "$name". Jeg skriver $foo -> foo .
Nå trekker jeg ut( $foo -> bar [ 1 ]) .
Dette skal skrive ut den store bokstaven "A": \x41
EOT;
?>

Mitt navn er "Navn". Jeg skriver Foo. Nå sender jeg ut Bar2. Dette skal skrive ut en stor bokstav "A": A

Det er også mulig å bruke heredoc-syntaks for å sende data gjennom funksjonsargumenter:

Siden versjon 5.3.0 har det blitt mulig å initialisere statiske variabler og klasseegenskaper/konstanter ved hjelp av heredoc-syntaks:

Eksempel #5 Bruke heredoc for å initialisere statiske variabler

// Statiske variabler
funksjon foo()
{
statisk $bar =<<Det er ingenting her...
MERKELAPP;
}

// Konstanter/klasseegenskaper
klasse foo
{
const BAR =<<Eksempel på bruk av en konstant
FOOBAR;

Offentlig $baz =<<Eksempel på bruk av et felt
FOOBAR;
}
?>

Fra og med PHP 5.3.0 kan du også omgi Heredoc-identifikatoren med doble anførselstegn:

Nådok

Nowdoc er det samme for strenger med enkle anførselstegn som heredoc er for strenger med dobbelte anførselstegn. Nowdoc ligner på heredoc, men inne i den ingen erstatninger gjøres. Denne designen er ideell for å bygge inn PHP-kode eller andre store tekstblokker uten å måtte unnslippe den. I dette er det litt likt SGML-konstruksjonen ved å erklære en tekstblokk som ikke er ment å bli behandlet.

Nowdoc er indikert med samme sekvens <<< , som brukes i heredoc, men følgende identifikator er omsluttet av enkle anførselstegn, for eksempel, <<<"EOT" . Alle betingelser som gjelder for heredoc-identifikatorer gjelder også for nowdoc, spesielt de som gjelder for den avsluttende identifikatoren.

Eksempel #7 Eksempel på bruk av nowdoc

ekko<<<"EOD"
Eksempeltekst,
spenner over flere linjer
bruker nowdoc-syntaks. Omvendt skråstrek behandles alltid bokstavelig,
for eksempel \\ og \".
EOD;

Resultatet av å kjøre dette eksemplet:

Eksempel på tekst som spenner over flere linjer ved hjelp av nowdoc-syntaks. Omvendt skråstrek behandles alltid bokstavelig, for eksempel \\ og \".

Eksempel #8 Nowdoc-streng som siterer eksempel med variabler

/* Mer komplekst eksempel med variabler. */
klasse foo
{
offentlig $foo ;
offentlig $bar ;

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

$foo = new foo();
$name = "Navn" ;

ekko<<<"EOT"
Mitt navn er "$name". Jeg skriver ut $foo->foo.
Nå skriver jeg ut ($foo->bar).
Dette skal ikke skrive ut stor "A": \x41
EOT;
?>

Resultatet av å kjøre dette eksemplet:

Mitt navn er "$name". Jeg skriver ut $foo->foo. Nå skriver jeg ut ($foo->bar). Dette skal ikke skrive ut stor "A": \x41

Eksempel #9 Eksempel på bruk av statiske data

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

Kommentar:

nowdoc-støtte ble lagt til i PHP 5.3.0.

Håndtering av variabler

Hvis strengen er spesifisert i doble anførselstegn, eller bruker heredoc, variabler behandles inne i den.

Det er to typer syntaks: enkel Og vanskelig. Enkel syntaks er enklere og mer praktisk. Det gjør det mulig å behandle en variabel, en matriseverdi ( array ) eller objektegenskaper ( gjenstand ) med et minimum av innsats.

Kompleks syntaks kan identifiseres av de krøllete klammeparentesene rundt uttrykket.

Enkel syntaks

Hvis tolken møter et dollartegn ( $ ), fanger den opp så mange tegn som mulig for å danne et gyldig variabelnavn. Hvis du vil spesifisere slutten av et navn, omslutter variabelnavnet i krøllete klammeparenteser.

$juice = "eple" ;

ekko "Han drakk litt $juicejuice." . PHP_EOL ;

// Stemmer ikke. "s" er et gyldig tegn for et variabelnavn, men variabelen heter $juice.
echo "Han drakk litt juice laget av $juice." ;

// Riktig. Slutten av variabelnavnet er strengt angitt med parenteser:
echo "Han drakk litt juice laget av $( juice ) s." ;
?>

Resultatet av å kjøre dette eksemplet:

Han drakk litt eplejuice. Han drakk litt juice laget av . Han drakk litt juice laget av epler.

Et matriseelement ( array ) eller objektegenskap ( gjenstand ). I matriseindekser er det en avsluttende firkantparentes ( ] ) markerer slutten på indeksdefinisjonen. De samme reglene gjelder for objektegenskaper som for enkle variabler.

Eksempel #10 Enkelt syntakseksempel

definere ("KOOLAID", "koolaid1" );
$juices = array("eple" , "oransje" , "koolaid1" => "lilla" );

ekko "Han drakk noen $juices [0] juice." . PHP_EOL ;
ekko "Han drakk noen $juices [1] juice." . PHP_EOL ;
echo "Han drakk noen $juices [ koolaid1 ] juice." . PHP_EOL ;

klassefolk (
public $john = "John Smith" ;
public $jane = "Jane Smith" ;
public $robert = "Robert Paulsen" ;

Offentlig $smith = "Smith" ;
}

$people = nye mennesker();

echo "$people -> john drakk noen $juices [ 0 ] juice." . PHP_EOL ;
echo " $people -> john sa deretter hei til $people -> jane ." . PHP_EOL ;
echo "$people -> johns kone hilste $people -> robert." . PHP_EOL;
echo " $people -> robert hilste på de to $people -> smedene ." ; // Vil ikke fungere
?>

Resultatet av å kjøre dette eksemplet:

Han drakk litt eplejuice. Han drakk appelsinjuice. Han drakk litt lilla juice. John Smith drakk litt eplejuice. John Smith sa deretter hei til Jane Smith. John Smiths kone hilste på Robert Paulsen, Robert Paulsen hilste på de to.

PHP 7.1.0 har lagt til støtte negativ numeriske indekser.

Eksempel #11 Negative numeriske indekser

$string = "streng" ;
ekko "Tegnet ved indeks -2 er lik$string [- 2 ] ." , PHP_EOL ;
$string [- 3 ] = "o" ;
ekko "Endring av tegnet i posisjon -3 til 'o' produserer følgende linje:$string." , PHP_EOL;
?>

Resultatet av å kjøre dette eksemplet:

Tegnet med indeks -2 er lik n. Å endre tegnet i posisjon -3 til "o" gir følgende linje: sterk

For noe mer komplekst, bruk kompleks syntaks.

Kompleks (krøllet) syntaks

Det kalles kompleks ikke fordi det er vanskelig å forstå, men fordi det tillater bruk av komplekse uttrykk.

Enhver skalarvariabel, matriseelement eller objektegenskap som er tilordnet til en streng, kan representeres i en streng ved å bruke denne syntaksen. Bare skriv uttrykket på samme måte som du ville gjort utenfor linjen og pakk det inn { Og } . Fordi det { ikke kan escapes, vil denne syntaksen bare gjenkjennes når $ følger direkte { . Bruk {\$ å printe {$ . Noen få illustrerende eksempler:

// Vis alle feil
feilrapportering(E_ALL);

$great = "flott" ;

// Fungerer ikke, utganger: Dette er (bra)
echo "Dette er ($great)" ;

// Fungerer, utganger: Dette er flott
echo "Dette er ($great)" ;

// Virker
ekko "Denne plassen er bred( $square -> width ) 00 centimeter." ;

// Fungerer, siterte nøkkelord fungerer bare med krøllete klammeparentes-syntaks
echo "Dette fungerer: ( $arr [ "nøkkel" ]) " ;

// Virker
echo "Dette fungerer: ( $arr [ 4 ][ 3 ]) " ;

// Dette er ugyldig av samme grunn som $foo utenfor
// linjer. Med andre ord, det vil fortsatt fungere,
// men siden PHP ser etter konstant foo først, vil dette føre til
// nivåfeil E_NOTICE (udefinert konstant).
ekko "Det er ikke riktig:( $arr [ foo ][ 3 ]) " ;

// Virker. Ved bruk av flerdimensjonale arrays internt
// linjer bruker alltid krøllete tannregulering
echo "Dette fungerer: ( $arr [ "foo" ][ 3 ]) " ;

// Virker.
echo "Dette fungerer: " . $arr [ "foo" ][ 3 ];

ekko "Dette fungerer også:($obj -> verdier [3]-> navn) " ;

ekko "Dette er verdien av variabelen som er navngitt$navn: ($($navn)) " ;

ekko "Dette er verdien av variabelnavnet som getName() returnerer:($( getName ())) " ;

ekko "Dette er verdien av variabelen etter navn som \$object->getName() returnerer:($( $object -> getName ())) " ;

// Fungerer ikke, utdata: Dette er hva getName() returnerer: (getName())
ekko "Dette er hva getName() returnerer: (getName())";
?>

Det er også mulig å få tilgang til objektegenskaper innenfor strenger ved å bruke denne syntaksen.

klasse foo (
var $bar = "Jeg er bar." ;
}

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

Resultatet av å kjøre dette eksemplet:

Jeg er bar. Jeg er bar.

Kommentar:

Funksjoner, metodekall, statiske klassevariabler og klassekonstanter fungerer internt {$} , som starter med PHP 5. Den oppgitte verdien vil imidlertid bli behandlet som et variabelnavn i samme kontekst som linjen den er definert i. Bruke enkle krøllete seler ( {} ) vil ikke fungere for å få tilgang til verdiene til funksjoner, metoder, klassekonstanter eller statiske klassevariabler.

// Vis alle feil
feilrapportering(E_ALL);

klasse øl (
const brus = "rootbeer" ;
offentlig statisk $ale = "ipa" ;
}

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

// Dette fungerer, gir ut: Jeg vil ha A & W
echo "Jeg vil ha ($( øl :: brus )) \n" ;

// Dette fungerer også, utganger: I would like Alexander Keith's
echo "Jeg vil ha ($( øl :: $ale )) \n" ;
?>

Få tilgang til og endre et tegn i en streng

Tegn i strenger kan brukes og endres ved å spesifisere deres offset fra begynnelsen av strengen, med start på null, i hakeparenteser etter strengen, for eksempel $str . Tenk på en streng for dette formålet som en rekke tegn. Hvis du trenger å få eller erstatte mer enn 1 tegn, kan du bruke funksjonene substr() Og substr_replace() .

Kommentar: Fra og med PHP 7.1.0 støttes negative offset-verdier. De spesifiserer forskyvningen fra slutten av linjen. Tidligere negative forskyvninger forårsaket en nivåfeil E_MERKNAD ved lesing (returnerer en tom streng) eller E_ADVARSEL ved skriving (forlater linjen uendret).

Kommentar: Et tegn i en streng kan også nås ved å bruke krøllete klammeparenteser, for eksempel $str(42) .

Merk følgende

Forsøk på å skrive til en forskyvning utenfor linjens grenser vil fylle strengen med mellomrom opp til denne forskyvningen. Ikke-heltallstyper vil bli konvertert til heltallstyper. Feil forskyvningstype vil forårsake en nivåfeil E_ADVARSEL. Bare det første tegnet i den tilordnede strengen brukes. Fra og med PHP 7.1.0 vil tilordning av en tom streng forårsake en fatal feil. Tidligere, i dette tilfellet, ble en null byte (NULL) tildelt.

Merk følgende

Strenger i PHP er interne arrays av byte. Som et resultat er det ikke trygt å få tilgang til eller endre en streng ved en forskyvning, og bør bare gjøres med strenger i enkeltbyte-kodinger, for eksempel ISO-8859-1.

Kommentar: Siden PHP 7.1.0 forårsaker bruk av en tom indeks en fatal feil; tidligere, i dette tilfellet, ble strengen konvertert til en matrise uten forvarsel.

Eksempel #12 Noen eksempelstrenger

// Få det første tegnet i strengen
$str = "Dette er en test." ;
$first = $str [0 ];

// Få det tredje tegnet i strengen
$tredje = $str [2];

// Få det siste tegnet i strengen
$str = "Dette er fortsatt en test." ;
$last = $str [ strlen ($str ) - 1 ];

// Endre det siste tegnet i linjen
$str = "Se på havet" ;
$str [ strlen ($str )- 1 ] = "e" ;

?>

Fra og med PHP 5.4 må forskyvningen i en streng spesifiseres som enten et heltall eller en streng som inneholder sifre, ellers vil det bli utstedt en advarsel. Tidligere offset gitt av en streng som "foo", uten forvarsel ble forvandlet til 0 .

Eksempel #13 Forskjeller mellom PHP 5.3 og 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 å kjøre dette eksemplet 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 å kjøre dette eksemplet i PHP 5.4:

string(1) "b" bool(true) Advarsel: Ulovlig strengforskyvning "1.0" i /tmp/t.php på linje 7 string(1) "b" bool(false) Advarsel: Ulovlig strengforskyvning "x" i / tmp/t.php på linje 9 string(1) "a" bool(false) string(1) "b" bool(false)

Kommentar:

Prøver å få tilgang til variabler av andre typer (unntatt arrays eller objekter som implementerer visse grensesnitt) ved å bruke eller {} vil stille tilbake NULL.

Kommentar:

PHP 5.5 la til støtte for å få tilgang til tegn i strengliteraler ved å bruke syntaksen eller {} .

Det er mange nyttige funksjoner for å endre strenger.

Hovedfunksjonene er beskrevet i avsnittet strengfunksjoner, og for avansert søk og erstatt - funksjoner Perl-kompatible regulære uttrykk.

Konverter til streng

En verdi kan konverteres til en streng ved hjelp av en cast (streng), eller funksjoner strval() . I uttrykk der det kreves en streng, skjer konverteringen automatisk. Dette skjer når du bruker funksjoner ekko eller skrive ut , eller når verdien til en variabel sammenlignes med en streng. Lese deler av håndboken Typer Og Type manipulasjon vil gjøre følgende klarere. se også setttype() .

Matriser konverteres alltid til streng "Array", så du kan ikke vise innholdet i matrisen ( array ), ved hjelp av ekko eller skrive ut for å se hva den inneholder. For å se et enkelt element, bruk noe sånt som echo $arr["foo"]. Se nedenfor for tips om hvordan du viser/viser alt innhold.

For å konvertere en typevariabel "Gjenstand" i type streng magisk metode brukes __toString.

Betydning NULL konverteres alltid til den tomme strengen.

Som du kan se ovenfor, gir ikke direkte konvertering av arrays, objekter eller ressurser til en streng noen nyttig informasjon om verdiene selv annet enn typene deres. En bedre måte å sende ut verdier for feilsøking er å bruke funksjoner print_r() Og var_dump() .

De fleste verdier i PHP kan konverteres til en streng for vedvarende lagring. Denne metoden kalles serialisering og kan gjøres ved hjelp av funksjonen serialize() .

Konvertering av strenger til tall

Hvis strengen gjenkjennes som en numerisk verdi, bestemmes den resulterende verdien og typen som følger.

Hvis strengen ikke inneholder noen av tegnene ".", "e" eller "E", og verdien av tallet faller innenfor området av heltall (definert PHP_INT_MAX), vil strengen bli gjenkjent som et heltall ( heltall ). I alle andre tilfeller regnes det som et flyttall ( flyte ).

Verdien bestemmes av begynnelsen av strengen. Hvis linjen starter med en gyldig numerisk verdi, vil denne verdien bli brukt. Ellers vil verdien være 0 (null). En gyldig numerisk verdi er ett eller flere sifre (som kan inneholde et desimaltegn), eventuelt etterfulgt av et tegn etterfulgt av en valgfri eksponent. Eksponenten er "e" eller "E" etterfulgt av ett eller flere sifre.

$foo = 1 + "10.5" ; // $foo er en flyte (11,5)
$foo = 1 + "-1.3e3" ; // $foo er en flyte (-1299)
$foo = 1 + "bob-1.3e3" ; // $foo er et heltall (1)
$foo = 1 + "bob3" ; // $foo er et heltall (1)
$foo = 1 + "10 små griser" ; // $foo er et heltall (11)
$foo = 4 + "10.2 små griser" ; // $foo er en flyte (14.2)
$foo = "10.0 griser" + 1 ; // $foo er flyte (11)
$foo = "10.0 griser" + 1.0 ; // $foo er flyte (11)
?>

For mer informasjon om denne konverteringen, se delen om strtod(3) i Unix-dokumentasjonen.

Hvis du vil teste noen av eksemplene i denne delen, kopier og lim den og følgende linje for å se hva som skjer:

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

Ikke forvent å få koden til et tegn ved å konvertere det til et heltall (som det for eksempel gjøres i C). For å konvertere tegn til deres ASCII-koder og tilbake, bruk funksjonene ord() Og chr() .

Implementeringsdetaljer for strengtype

7 år siden

Dokumentasjonen nevner ikke, men et avsluttende semikolon på slutten av heredoc tolkes faktisk som et ekte semikolon, og fører som sådan noen ganger til syntaksfeil.

$foo =<<abcd
SLUTT;
?>

Dette betyr ikke:

foo (<<abcd
SLUTT;
);
// syntaksfeil, uventet ";"
?>

Uten semikolon fungerer det fint:

foo (<<abcd
SLUTT
);
?>

3 år siden

Du kan bruke strenglignende rekke av røye (som C)

$a = "String array test";

var_dump($a);
// Return string(17) "String array test"

var_dump($a);
// Returstreng(1) "S"

// -- Med array cast --
var_dump((matrise) $a);
// Return array(1) ( => string(17) "String array test")

var_dump((matrise) $a);
// Returstreng(17) "S"

Norihiori

1 år siden

Ethvert enkelt uttrykk, uansett hvor komplekst, som starter med $ (dvs. en variabel) kan ()-innebygges i en streng med doble anførselstegn:

Ekko "Uttrykket ( $h -> q ()[ "x)" ]-> p (9 == 0 ? 17 : 42 )) blir analysert like godt som ". $h -> q ()[ "x)" ]-> p (9 == 0 ? 17 : 42) . "gjør." ;

?>

2 år siden

Begge burde fungere :(

Klassetesting (
offentlig statisk $VAR = "statisk" ;
public const VAR = "const" ;

Offentlig funksjon siHelloStatic() (
echo "hei: ($this :: $VAR)" ;
}

Offentlig funksjon siHelloConst() (
echo "hello: ( $this ::VAR) " ; //Parse error: syntaksfeil, uventet ")", forventer "["
}
}

$obj = ny testing();
$obj -> siHelloStatic();
$obj -> siHelloConst ();

14 år siden

Du kan bruke den komplekse syntaksen til å sette verdien til både objektegenskaper OG objektmetoder i en streng. For eksempel...
klasseTest{
offentlig$one= 1 ;
offentlig funksjonto() {
komme tilbake2 ;
}
}
$test= nyTest();
ekko"foo{ $test-> en} bar{ $test-> to()} " ;
?>
Vil gi ut "foo 1 bar 2".

Du kan imidlertid ikke gjøre dette for alle verdier i navneområdet ditt. Klassekonstanter og statiske egenskaper/metoder vil ikke fungere fordi den komplekse syntaksen ser etter "$".
klasseTest{
konstEN= 1 ;
}
ekko"foo (Test::ONE) bar";
?>
Dette vil gi ut "foo (Test::one) bar". Konstanter og statiske egenskaper krever at du bryter opp strengen.

6 år siden

Førende nuller i strenger blir (minst overraskelse) ikke behandlet som oktale.
Ta i betraktning:
$x = "0123" + 0;
$y = 0123 + 0;
echo "x er $x, y er $y"; //skriver ut "x er 123, y er 83"
med andre ord:
* innledende nuller i numeriske bokstaver i kildekoden tolkes som "oktale", jf. f.eks. strtol().
* innledende nuller i strenger (f.eks. brukerinnsendte data), når cast (implisitt eller eksplisitt) til heltall ignoreres, og betraktes som desimal, c.f. strtod().

3 år siden

Vær oppmerksom på at samsvar med "Stringkonvertering til tall":

hvis ("123abc"== 123 ) ekko"(intstr == int) tester feilaktig som sann.";

// Fordi den ene siden er et tall, blir strengen feil konvertert fra intstr til int, som deretter samsvarer med testnummeret.

// Sann for alle betingelser som if og switch-setninger (sannsynligvis også while-løkker)!

// Dette kan være en stor sikkerhetsrisiko når du tester/bruker/lagrer brukerinndata, mens du forventer og tester kun et heltall.

// Det ser ut til at den eneste løsningen er at 123 er en streng som "123", så ingen konvertering skjer.

?>

For 10 år siden

Her er et enkelt hack for å la strenger og herdokser med doble anførselstegn inneholde vilkårlige uttrykk i syntaks med krøllete klammer, inkludert konstanter og andre funksjonskall:

// Hack-erklæring
funksjon_expr($v) (komme tilbake$v; }
$_expr= "_expr";

// Lekeplassen vår
definere("qwe", "asd");
definere("zxc", 5 );

$a= 3 ;
$b= 4 ;

funksjon c($a, $b) (komme tilbake$a+ $b; }

//Bruk
ekko"før{ $_expr(1 + 2 )} post\n"; // gir ut "pre 3 post"
ekko"før{ $_expr(qwe)} post\n"; // gir ut "pre asd post"
ekko"før{ $_expr(c($a, $b)+ zxc* 2 )} post\n"; // gir ut "før 17 innlegg"

// Generell syntaks er ($_expr(...))
?>

11 år siden

For å redde tankene dine, ikke les tidligere kommentarer om datoer ;)

Når begge strengene kan konverteres til numeriske (i ("$a" > "$b") test), brukes de resulterende numeriske, ellers sammenlignes FULL strenger tegn-for-tegn:

var_dump("1.22" > "01.23" ); //bool(false)
var_dump("1.22.00" > "01.23.00" ); //bool(true)
var_dump("1-22-00" > "01-23-00" ); //bool(true)
var_dump((flyte)"1.22.00" > (flyte)"01.23.00" ); //bool(false)
?>

2 år siden

Jeg tenkte at det ville være nyttig å legge til denne kommentaren slik at informasjonen i det minste vises på høyre side på PHP-siden.

Merk at hvis du har tenkt å bruke en streng med doble anførselstegn med en assosiativ nøkkel, kan du støte på feilen T_ENCAPSED_AND_WHITESPACE. Noen anser dette som en av de mindre åpenbare feilmeldingene.

Et uttrykk som:

$frukt=array(
"en"=> "eple",
"b"=> "banan",
//etc
);

Skrive ut "Dette er en$frukt[ "en"]"; // T_ENCAPSED_AND_WHITESPACE
?>

vil definitivt falle i stykker.

Du kan løse det på følgende måte:

skrive ut"Dette er en$frukt[ en] " ; // fjern anførselstegn fra nøkkelen
skrive ut"Dette er en${ frukt[ "en"]} " ; // Kompleks syntaks
skrive ut"Dette er en{ $frukt[ "en"]} " ; // Kompleks syntaksvariasjon
?>

Jeg har en personlig preferanse for den siste varianten da den er mer naturlig og nærmere hvordan uttrykket ville vært utenfor strengen.

Det er ikke klart (i det minste for meg) hvorfor PHP feiltolker det enkelte sitatet inne i uttrykket, men jeg forestiller meg at det har noe å gjøre med at sitater ikke er en del av verdistrengen - når strengen allerede er analysert, er sitatene bare komme i veien... ?

Hei kjære nybegynnere programmerere. La oss fortsette å studere elementene som utgjør.

I denne artikkelen vil vi lære hva som er php-operatører. Faktisk har vi vært kjent med noen av dem nesten siden barndommen, men vi kjenner dem bare som tegn (+, -, =, !, ?).

I php kalles de alle operatører, noe som er ganske logisk, siden de utfører en spesifikk handling eller operasjon.

Du kan til og med si at alle utskrivbare tegn som ikke er en bokstav eller et tall, er operatorer i PHP. Men det er ikke alt, siden det er operatører som består av bokstaver.

La oss starte i rekkefølge.

Aritmetiske operatorer

Aritmetiske operatorer brukes til å utføre operasjoner på tall.

+ er addisjonsoperatoren;
— — subtraksjonsoperatør;
/ - divisjonsoperatør;
* — multiplikasjonsoperator;
% er operatøren for å oppnå resten under deling;
++ — operator for å øke med én (økning);
— — — redusere med én operatør (nedgang)

Ved skriving plasseres vanligvis et mellomrom før og etter operatøren. Dette gjøres utelukkende for å lette å lese koden, selv om denne plassen ikke påvirker noe, og du kan klare deg uten den hvis du ønsker det.

Komplekse uttrykk er komponert etter reglene som er akseptert i aritmetikk, det vil si at multiplikasjon og divisjon har prioritet fremfor addisjon og subtraksjon, og når begge er tilstede i uttrykket, er sistnevnte satt i parentes.

ekko (6 + 7) * (7 + 8); // 195
?>

Når du utfører handlingen med å dele et heltall med et heltall, i tilfelle du oppnår en rest, blir resultatet automatisk konvertert til et reelt tall (flyttall).

ekko 8/3; //2.66666666666
?>

Antall sifre som skrives ut for et brøktall avhenger av verdien satt i presisjonsdirektivet som finnes i php.ini-filen. Vanligvis er dette 12 tegn som ikke teller punktum.

Operatoren % brukes vanligvis til å bestemme om ett tall er delelig med et annet uten en rest eller ikke.

ekko 53328 % 4 ; //0
?>

Operasjoner med aritmetiske operatorer, med unntak av inkrement og dekrement, kalles binær, siden de involverer to operander (term + term, utbytte / divisor, etc.)

Handlingene med økning og reduksjon kalles unær, siden de involverer én operand. Er det noen flere betinget drift, som involverer tre operander.

Operatorene inkrement (++) og reduksjon (- -) gjelder bare for variabler.

Variabel type heltall (hele tall)

$neste = 3 ;
ekko +$neste; // 4
?>

Variabel type streng

$next = "abc";
ekko $neste; // abd
?>

Bokstaven "d" skrives ut i stedet for bokstaven "c" fordi den er neste i alfabetet og vi økte verdien av variabelen med én.

Eksemplene viser handlinger med inkrement, og på samme måte kan du utføre handlinger med dekrement.

Bitvise operatører

Bitvise operatører er designet for å fungere med binære data. Hvis noen ikke aner hva det er, skal jeg forklare. Binære tall er tall som 1001000011100000111000.

Siden slike data nesten aldri brukes i utvikling av nettsteder, vil vi ikke dvele ved dem i detalj. Jeg skal bare vise deg hvordan de ser ut, slik at når du møter slike symboler kan du forestille deg hva du har å gjøre med.

& - bitvis tilkobling OG (og);
~ — bitvis negasjon (ikke);
| — bitvis union OR (eller);
^ — bitvis eliminering ELLER (xor);
<< — сдвиг влево битового значения операнда;
>> — skift til høyre bitverdien til operanden;

Det er ganske sannsynlig at du vil møte disse operatørene, siden binære data er mye brukt i utviklingen av datagrafikkprogrammer. Men for å studere dem, hvis noen trenger det, må de ta et eget kurs på en annen ressurs.

Sammenligningsoperatører

Sammenligningsoperatorer er logiske operatorer og brukes til å sammenligne variabler. Matriser og objekter kan ikke sammenlignes ved å bruke dem.

> - operatør større enn;
=> - større enn eller lik operator;
< — оператор меньше;
<= — оператор меньше или равно;
== — likhetsoperatør;
!= — ulikhetsoperatør;
=== — ekvivalensoperator (verdien og typen av variabelen er like);
!== — ikke-ekvivalensoperatør;

Som et resultat av sammenligningen vises enten en på skjermen, som tilsvarer sann (true), eller en tom streng, som tilsvarer usann (false).

ekko 1 > 0; // 1
ekko 1< 0 ; // пустая строка
ekko 1 => 0 ; // 1
ekko 1 == 1; // 1
?>

Så i seg selv blir sammenligningsoperatører nesten aldri brukt. Hovedformålet deres er å arbeide sammen med if-setningen.

Betingede utsagn hvis, annet, annet.

Betingede operatører kalles så fordi de er designet for å teste en bestemt tilstand, avhengig av hvilken bestemt handling som utføres.

If-setningen tar en boolsk variabel, eller uttrykk, som et argument. Hvis betingelsen er sann, vises resultatet, hvis det ikke er sant, vises en tom linje.

if ($neste< $nexT)
{
ekko "Sanse for nedbør"; // Utgang Nedbør mulig
}
?>

$next = "Luftfuktighet 80%";
$nexT = "Luftfuktighet 90%";
if ($next > $nexT)
{
ekko "Sanse for nedbør"; // Skriv ut en tom linje
}
?>

Hvis programmet trenger å spesifisere to handlinger, hvorav den ene utføres hvis verdien er sann, og den andre hvis verdien er usann, brukes else-setningen sammen med if-setningen.

$next = "Luftfuktighet 80%";
$nexT = "Luftfuktighet 90%";
if ($next > $nexT)
{
ekko "Sanse for nedbør";
}
ellers
{
ekko "Ingen nedbør forventet";
}
?>

I dette tilfellet vil "Nedbør forventes ikke" vises, og hvis du i uttrykket endrer tegnet "Mer" til "Mindre", vil "Nedbør er mulig" vises. Dette er hvordan betingede operatører sjekker en tilstand og gir ut riktig resultat i henhold til den.

Svært ofte er det behov for å sette mer enn to betingelser, og deretter, for å kontrollere dem sekvensielt, brukes elseif-operatøren.

if ($next > $nexT)
{
ekko "Jeg ser";
}
elseif ($neste<= $nexT)
{
ekko "Snø";
}
elseif ($next >= $nexT)
{
ekko "Regn";
}
elseif ($next == $nexT)
{
ekko "Tørke";
}
ellers
{
ekko "Sanse for nedbør";
}
?>

Dette programmet vil sende ut "Snø". Hvis ingen av forholdene stemte overens, ville det vise "Sanse for nedbør."

En if-setning kan inneholde så mange elseif-blokker du vil, men bare én else-setning.

Et alternativt opptaksalternativ er tillatt - uten bukseseler. I dette tilfellet slutter linjene i if, else, elseif-setningene med et kolon, og hele konstruksjonen ender med nøkkelordet (operator) endif.

$next = "Luftfuktighet 50%";
$nexT = "Luftfuktighet 60%";
if ($neste<= $nexT):

ekko "Snø";

elseif ($next >= $nexT):

ekko "Regn";

elseif ($next == $nexT):

ekko "Tørke";

ellers:

ekko "Sanse for nedbør";
slutt om ;
?>

Logiske operatører

Logiske operatorer ligner på bitvise operatorer. Forskjellen mellom dem er at førstnevnte opererer med logiske variabler, og sistnevnte med tall.

Logiske operatorer brukes i tilfeller der du trenger å kombinere flere forhold, noe som vil redusere antall if-setninger, som igjen reduserer sannsynligheten for feil i koden.

&& - forbindende konjunksjon AND;
og - også OG, men med lavere prioritet;
|| - skillende konjunksjon ELLER;
eller - også OR, men med lavere prioritet;
xor - eksklusiv ELLER;
! - fornektelse;

Lavere prioritet betyr at hvis begge operatørene er til stede, blir den med høyere prioritet utført først.

I fremtiden, ved å bruke eksempler på mer komplekse skript, vil vi dvele mer detaljert på logiske operatorer.

Oppdragsoperatør

Tilordningsoperatoren = tildeler verdien av høyre operand til venstre operand.

$next = "Hei"
echo "Hei" // Hei
?>

Operatør prikk

Punktoperatoren skiller heltallsdelen av et tall fra brøkdelen, og kombinerer flere strenger og et tall til en hel streng.

$neste = 22 ;
ekko "I dag etter" .$neste. "frost er forventet"; // I dag etter 22 er det ventet frost
?>

Operator for parenteser

Som i matematikk, prioriterer parentesoperatoren handlingen som er innelukket i dem.

Dataene i parentes utføres først, og deretter resten.

Operatør med krøllete tannregulering

Det er tre måter, eller til og med stiler, for å plassere krøllete seler i PHP.

1. BSD-stil - parentes er justert til venstre.

if ($neste)
{

}

2. GNU-stil - parentes er justert innrykket fra venstre kant

if ($neste)
{
ekko "Hei kjære begynnende programmerere";
}

3. K&R-stil - parentes åpnes på operatørlinjen

if ($neste)(
ekko "Hei kjære begynnende programmerere";
}

Helt fra begynnelsen må du velge en av stilene og i fremtiden, når du skriver skript, bruk bare den. Dessuten spiller det ingen rolle hvilken stil du foretrekker. Det er viktig at det er enhetlig gjennom hele programmet.

Jeg tror det er nok for nå. I prinsippet kan ikke bare skilt, men også funksjoner og andre elementer være operatører, så det er veldig vanskelig å liste dem alle, og det er ingen vits.

Det er nok å ha en ide om det grunnleggende. Og vi vil analysere resten ved å bruke praktiske eksempler.

En irer vandrer rundt i Sheremetyevo flyplass i tårer. En av de ansatte bestemte seg for å sympatisere:
— Savner du hjemlandet ditt?
- Ikke i det hele tatt. Jeg har nettopp mistet all bagasjen min
– Hvordan kunne dette skje?
– Jeg forstår ikke meg selv. Ser ut som jeg har plugget inn støpselet ordentlig