Hei kjære nybegynnere programmerere. La oss fortsette å studere elementene den består av.
I denne artikkelen vil vi lære hva php-utsagn er. Faktisk er vi kjent med noen av dem nesten fra barndommen, bare vi kjenner dem som tegn (+, -, =,!,?).
I php kalles de alle operatører, noe som er ganske logisk, siden de utfører en bestemt handling eller operasjon.
Du kan til og med si at alle utskrivbare tegn som ikke er bokstaver eller 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 å manipulere tall.
+ - tilleggsoperatør;
- - subtraksjonsoperatør;
/ - divisjonsoperatør;
* - operatør for multiplikasjon;
% - operatør for å oppnå resten ved deling;
++ - operator for økning med én (økning);
- - - operatør for reduksjon med én (dekrement)
Ved skriving brukes vanligvis et mellomrom før og etter operatøren. Dette gjøres utelukkende for å gjøre det enklere å lese koden, selv om dette gapet ikke påvirker noe, og om ønskelig kan du klare deg uten det.
Komplekse uttrykk er komponert etter reglene som er akseptert i aritmetikk, det vil si at multiplikasjon og divisjon har forrang 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 av oppnåelse av resten, blir resultatet automatisk konvertert til et reelt tall (flyttall).
ekko 8/3; //2.66666666666
?>
Antall tegn som vises for et brøktall, avhenger av verdien satt i presisjonsdirektivet i php.ini-filen. Dette er vanligvis 12 tegn eksklusive punktum.
Operatoren % brukes vanligvis til å bestemme om ett tall er delelig med et annet uten en rest eller ikke.
ekko 53328% 4; // 0
?>
Handlinger med aritmetiske operatorer, med unntak av økning og dekrementering, kalles binær, siden de involverer to operander (term + term, utbytte / divisor, etc.)
Inkrement- og reduksjonshandlingene kalles unær, siden de involverer én operand. Er det noen flere betinget drift, der tre operander er involvert.
Operatorene inkrement (++) og reduksjon (- -) gjelder bare for variabler.
Variabel type heltall (heltall)
$ neste = 3;
echo ++ $ neste; // 4
?>
Variabel type streng (streng)
$ neste = "abc";
echo $ neste; // abd
?>
Bokstaven "d" vises i stedet for bokstaven "c" fordi den er neste i alfabetet, og vi har økt verdien på variabelen med én.
Eksemplene viser inkrementelle handlinger, og du kan utføre dekrementelle handlinger på samme måte.
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 utviklingen av nettsider, 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 sammensatt OG (og);
~ - bitvis negasjon (ikke);
| - bitvis union OR (eller);
^ - bitvis ekskludering ELLER (xor);
<<
— сдвиг влево битового значения операнда;
>> - høyreforskyvning av bitverdien til operanden;
Møte med disse operatørene er ganske sannsynlig, siden binære data er mye brukt i utviklingen av datagrafikkprogrammer. Men for å studere dem, hvis noen trenger det, må du 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 med deres hjelp.
> - operatøren er større;
=> - operator større enn eller lik;
<
— оператор меньше;
<=
— оператор меньше или равно;
== - operatørlikhet;
! = - operatorulikhet;
=== - operatør av ekvivalens (verdien og typen av variabelen er like);
! == - ikke-ekvivalensoperator;
Som et resultat av sammenligningen vises enten en på skjermen, som tilsvarer sann (sann), eller en tom streng, som tilsvarer usann (falsk).
ekko 1> 0; // 1
ekko 1<
0
;
// пустая строка
ekko 1 => 0; // 1
ekko 1 == 1; // 1
?>
Dette er hvordan sammenligningsoperatører i seg selv nesten aldri brukes. Hovedformålet deres er å jobbe sammen med if-utsagnet.
Betingede utsagn hvis, annet, annet.
Betingede operatører kalles det fordi de er designet for å teste en bestemt tilstand, avhengig av hvilken en eller annen handling som utføres.
Som et argument tar if-setningen en boolsk variabel eller uttrykk. Hvis betingelsen er sann, vises resultatet, hvis ikke sant - en tom streng.
hvis ($ neste< $nexT)
{
ekko "Sanse for nedbør"; // Vises Mulig nedbør
}
?>
$ neste = "Luftfuktighet 80%";
$ nexT = "Luftfuktighet 90%";
if ($ neste> $ nexT)
{
ekko "Sanse for nedbør"; // Vis tom streng
}
?>
Hvis du trenger å angi to handlinger i programmet, hvorav den ene utføres hvis verdien er sann, og den andre hvis den er usann, brukes else-operatoren sammen med if-setningen
$ neste = "Luftfuktighet 80%";
$ nexT = "Luftfuktighet 90%";
if ($ neste> $ nexT)
{
ekko "Sanse for nedbør";
}
ellers
{
ekko "Ingen nedbør forventet";
}
?>
I dette tilfellet vil "Nedbør forventes ikke" vises, og endrer du skiltet "Mer" til "Mindre" i uttrykket, vil "Mulig nedbør" vises. Dette er hvordan betingede operatører kontrollerer tilstanden, og gir riktig resultat i henhold til den.
Svært ofte blir det nødvendig å angi mer enn to betingelser, og deretter, for å teste dem sekvensielt, brukes elseif-operatoren.
if ($ neste> $ nexT)
{
ekko "Jeg ser";
}
elseif ($ neste<= $nexT)
{
ekko "Snø";
}
elseif ($ neste> = $ nexT)
{
ekko "Regn";
}
elseif ($ neste == $ nexT)
{
ekko "Tørke";
}
ellers
{
ekko "Sanse for nedbør";
}
?>
Dette programmet vil vise "Snø". Hvis ingen av forholdene passer, vil "Nedbør mulig" vises.
En if-setning kan inneholde så mange elseif-blokker du vil, og bare én else-setning.
En alternativ notasjon er tillatt - uten bukseseler. I dette tilfellet ender linjene i if, else, elseif-setningene med et kolon, og hele konstruksjonen ender med endif-nøkkelordet (operator).
$ neste = "Luftfuktighet 50%";
$ nexT = "Luftfuktighet 60%";
hvis ($ neste<= $nexT):
ekko "Snø";
elseif ($ neste> = $ nexT):
ekko "Regn";
elseif ($ neste == $ 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 når du skal kombinere flere forhold, noe som vil redusere antallet if-setninger, som igjen vil redusere sannsynligheten for feil i koden din.
&& - kobler union OG;
og - også OG, men med lavere prioritet;
|| - skille fagforening OR;
eller - også OR, men med lavere prioritet;
xor - eksklusive ett OR-element;
! - fornektelse;
Lavere prioritet betyr at hvis begge operatørene er tilstede, blir den med høy prioritet utført først.
I fremtiden, på eksempler på mer komplekse skript, vil vi dvele mer detaljert på logiske operatorer.
Oppdragsoperatør
Tilordningsoperatoren = tildeler venstre oper og verdien til høyre.
$ neste = "Hei"
echo "Hei" // Hei
?>
Punktoperatør
Punktoperatoren skiller heltallsdelen av et tall fra brøkdelen, og setter sammen flere strenger og et tall til en hel streng.
$ neste = 22;
echo "I dag er etter". $ neste. "frost er forventet"; // Det er ventet frost etter 22 i dag
?>
Parentes operatør
Som i matematikk gir parentesoperatoren forrang til handlingen som er omsluttet av dem.
Først utføres dataene i parentes, og deretter alt annet.
Operatør for krøllete tannregulering
Det er tre måter, eller til og med stil, i php å plassere krøllete tannregulering.
1. BSD-stil - parentes er venstrejustert.
hvis ($ neste)
{
}
2.Gnu-stil - parenteser er rykket inn fra venstre
hvis ($ neste)
{
ekko "Hei kjære nybegynnere programmerere";
}
3. K&R-stil - parentesen åpnes i setningslinjen
hvis ($ neste) (
ekko "Hei kjære nybegynnere 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.
Foreløpig tror jeg det er nok. 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 ingenting å gjøre med det.
Det er nok å ha en ide om de grunnleggende grunnleggende. Og resten vil bli analysert ved hjelp av praktiske eksempler.
En irer vandrer rundt på flyplassen i Sheremetyevo 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 ha skjedd?
«Jeg forstår ikke. Det virker som jeg har plugget inn støpselet
Variabel $ GLOBALS... En assosiativ matrise som inneholder referanser til alle de gjeldende definerte globale skriptomfangsvariablene. Variablenavn er matrisenøkler.
For å erklære en global variabel, legg den bare inn i $ GLOBAL-matrisen
$ GLOBALS ["testkey2"] = "testverdi2";
Du kan vise alle verdiene til variablene i $ GLOBALS-matrisen ved å bruke print_r ($ GLOBALS); eller slik:
Foreach ($ GLOBALS som $-tast => $-verdi) ekko "GLOBALS [". $ Key. "] ==". $ Value. "
";
Variabel $ _SERVER.
Variabelen $ _REQUEST- en assosiativ matrise (array), som som standard inneholder dataene til variablene $ _GET, $ _POST og $ _COOKIE. Variabler i $ _REQUEST-matrisen sendes til skriptet via GET-, POST- eller COOKIE-metodene, så de kan ikke stoles på fordi de kan ha blitt endret av en ekstern bruker. Deres tilstedeværelse og rekkefølgen for å legge til data til de tilsvarende matrisene bestemmes av variables_order-direktivet (GPCS er angitt som standard).
Variabel $ _SESSION
Variabel $ _ENV... Fylles ut hvis skriptet ble lansert fra kommandolinjen. $ _SERVER-matrisen vil inneholde alle variablene fra $ _ENV-matrisen.
Variabel $ http_response_header
Kommentar: I PHP 7.0.0 på 64-biters plattformer er det ingen strenglengdegrense som kan nås, på 32-biters systemer og i tidligere versjoner av PHP kan strenger ikke 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 ( " ).
For å bruke et enkelt anførselstegn i en streng, unnslipp det med en omvendt skråstrek ( \ ). Hvis du trenger å skrive selve skråstreken, duplisere den ( \\ ). All annen bruk av omvendt skråstrek vil bli tolket som vanlige tegn, noe som betyr at hvis du prøver å bruke andre escape-sekvenser som f.eks. \ r eller \ n, vil de vises 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 normalt";
// Utganger: Arnold sa en gang "Jeg" kommer tilbake "
ekko "Arnold sa en gang," jeg kommer tilbake";
Ekko "Har du fjernet C: \\ *. *?";
// Utganger: Har du fjernet C: \ *. *?
echo "Har du fjernet C: \ *. *?" ;
// Utganger: Dette vil ikke bli utvidet: \ n ny linje
ekko "Dette vil ikke bli utvidet: \ n nylinje";
// Utganger: Variabler $ utvides også $ enten ikke utvidet
ekko "Variabler $ utvider utvides heller ikke $";
?>
Doble anførselstegn
Hvis en streng er omsluttet av doble anførselstegn ("), gjenkjenner PHP følgende escape-sekvenser for spesialtegn:
| Etterfølge | Betydning |
|---|---|
| \ n | nylinje (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 uttrykkstegn i oktal som flyter stille over for å passe inn i en byte (dvs. "\ 400" === "\ 000") |
| \ x (1,2) | en sekvens av tegn som samsvarer med et regulært uttrykkstegn i heksadesimal notasjon |
| \ u (+) | en sekvens av tegn som samsvarer med et Unicode-tegnregex som tilordnes til en streng i UTF-8-notasjon (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å skråstrek inn \ ($ var) ble ikke skrevet ut.
Heredoc
Den tredje måten å definere strenger på er ved å bruke heredoc-syntaksen: <<< ... Etter denne operatoren må du spesifisere en identifikator, deretter en linjemating. Etter det kommer selve linjen, og deretter den samme identifikatoren som lukker innlegget.
Linje bør start med en avsluttende identifikator, dvs. den må være 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 linjen med den avsluttende identifikatoren ikke må inneholde andre tegn, med unntak av semikolon ( ; ). Dette betyr at identifikatoren må 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 for å mangle og PHP vil fortsette å søke etter den videre. Hvis i dette tilfellet den riktige avsluttende identifikatoren fortsatt ikke er funnet, vil dette føre til en parsefeil med et linjenummer på slutten av skriptet.
Eksempel # 1 Feil syntakseksempel
klasse foo (
offentlig $ bar =<<
EOT;
// innrykk før den avsluttende identifikatoren er ikke tillatt
}
?>
Eksempel # 2 Korrekt syntakseksempel
klasse foo (
offentlig $ bar =<<
EOT;
}
?>
Heredoc kan ikke brukes til å initialisere klassefelt. Siden PHP 5.3 gjelder denne begrensningen kun for heredocs som inneholder variabler.
Heredoc-tekst oppfører seg på samme måte som en streng med 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 når du bruker komplekse variabler inne i heredoc, må du være like forsiktig som når du arbeider med strenger.
Eksempel # 3 Eksempel på å definere en heredoc-streng
$ str =<<
spenner over flere linjer,
ved hjelp av heredoc-syntaks.
EOD;
Klasse foo
{
var $ foo;
var $ bar;
Funksjon __konstruksjon ()
{
$ this -> foo = "Foo";
$ dette ->
}
}
$ foo = ny foo ();
$ navn = "Navn";
ekko<<
Nå tar jeg frem($ foo -> bar [1]) .
Dette skal skrive ut en stor "A": \ x41
EOT;
?>
Mitt navn er "Imarek". Jeg skriver Foo. Nå viser jeg Bar2. Dette skal skrive ut en stor "A": A
Det er også mulig å bruke heredoc-syntaksen til å sende data gjennom funksjonsargumenter:
Fra og med versjon 5.3.0 ble det mulig å initialisere statiske variabler og klasseegenskaper/konstanter ved å bruke heredoc-syntaksen:
Eksempel # 5 Bruke heredoc for å initialisere statiske variabler
// Statiske variabler
funksjon foo ()
{
statisk $ bar =<<
MERKELAPP;
}
// Klassekonstanter / egenskaper
klasse foo
{
const BAR =<<
FOOBAR;
Offentlig $ baz =<<
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 doble anførselstegn. Nowdoc er som heredoc, men inne i det ingen erstatninger utføres... Denne konstruksjonen er ideell for å bygge inn PHP-kode eller andre store tekstblokker uten behov for å rømme. I dette er det litt som SGML-konstruksjon. ved å erklære en tekstblokk som ikke skal behandles.
Nowdoc er indikert med samme sekvens <<< , som brukes i heredoc, men identifikatoren etter den er omsluttet av enkle anførselstegn, for eksempel, <<<"EOT" ... Alle vilkår som gjelder for heredoc-identifikatorer gjelder også for nowdoc, spesielt de som er knyttet til den avsluttende identifikatoren.
Eksempel # 7 Eksempel ved 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 dette eksemplet:
Eksempeltekst 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;
Funksjon __konstruksjon ()
{
$ this -> foo = "Foo";
$ this -> bar = array ("Bar1", "Bar2", "Bar3");
}
}
$ foo = ny foo ();
$ navn = "Navn";
ekko<<<"EOT"
Mitt navn er "$ navn". Jeg skriver $ foo-> foo.
Nå skriver jeg ($ foo-> bar).
Dette skal ikke skrive ut en stor "A": \ x41
EOT;
?>
Resultatet av dette eksemplet:
Mitt navn er "$ navn". Jeg skriver $ foo-> foo. Nå skriver jeg ($ foo-> bar). Dette skal ikke skrive ut en stor "A": \ x41
Eksempel # 9 Eksempel ved bruk av statiske data
klasse foo (
offentlig $ bar =<<<"EOT"
bar
EOT;
}
?>
Kommentar:
Nowdoc-støtte ble lagt til i PHP 5.3.0.
Variabel håndtering
Hvis strengen er spesifisert i doble anførselstegn, eller ved hjelp av heredoc, behandles variablene i den.
Det er to typer syntaks: enkel og kompleks. Enkel syntaks er enklere og mer praktisk. Det gjør det mulig å behandle en variabel, verdien av en matrise ( 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 ( $ ), den fanger så mange tegn som mulig for å danne det riktige variabelnavnet. Hvis du vil definere slutten av et navn nøyaktig, omslutter variabelnavnet i krøllete klammeparenteser.
$ juice = "eple";
ekko "Han drakk litt juice juice." ... PHP_EOL;
// Stemmer ikke. "s" er et gyldig tegn for et variabelnavn, men variabelen heter $ juice.
echo "Han drakk litt juice laget av $-juicer." ;
// Riktig. Slutten av variabelnavnet er strengt spesifisert med parenteser:
echo "Han drakk litt juice laget av $ (juice) s." ;
?>
Resultatet av dette eksemplet:
Han drakk litt eplejuice. Han drakk litt juice laget av. Han drakk litt juice laget av epler.
Matriseelementet ( array) eller objekteiendom ( gjenstand). I matriseindekser, den avsluttende firkantparentesen ( ] ) angir slutten av indeksdefinisjonen. De samme reglene gjelder for objektegenskaper som for enkle variabler.
Eksempel # 10 Enkelt syntakseksempel
definere ("KOOLAID", "koolaid1");
$ juice = array ("eple", "oransje", "koolaid1" => "lilla");
echo "Han drakk noen $ juice [0] juice." ... PHP_EOL;
echo "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";
}
$ mennesker = nye mennesker ();
echo "$ people -> john drakk noen $ juices [0] juice." ... PHP_EOL;
echo "$ people -> john sa hei til $ people -> jane." ... PHP_EOL;
echo "$ people -> john"s kone hilste $ people -> robert. ". PHP_EOL;
echo "$ folk -> robert hilste de to $ folk -> smeder." ; // Vil ikke fungere
?>
Resultatet av 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 legger til støtte for negativ numeriske indekser.
Eksempel # 11 Negative numeriske indekser
$ string = "streng";
ekko "Tegnet med indeks -2 er$ string [- 2]. ", PHP_EOL;
$ string [- 3] = "o";
ekko "Endring av tegnet i posisjon -3 til" o "gir følgende linje:$ string. ", PHP_EOL;
?>
Resultatet av dette eksemplet:
Tegnet med indeks -2 er 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 vanskelig ikke fordi det er vanskelig å forstå, men fordi det tillater bruk av komplekse uttrykk.
Enhver skalarvariabel, matriseelement eller objektegenskap som er tilordnet en streng, kan representeres på en streng med denne syntaksen. Bare skriv uttrykket på samme måte som utenfor linjen og omslutt det deretter { og } ... For så vidt { ikke kan escapes, vil denne syntaksen bare gjenkjennes når $ følger umiddelbart etter { ... Bruk {\$ å printe {$ ... Noen få illustrerende eksempler:
// Vis alle feil
feilrapportering (E_ALL);
$ flott = "flott";
// Fungerer ikke, utganger: Dette er (bra)
echo "Dette er ($ flott)";
// Fungerer, utganger: Dette er flott
echo "Dette er ($ flott)";
// Virker
ekko "Denne plassen er bred($ square -> width) 00 centimeter. ";
// Fungerer, angitte taster fungerer kun med krøllete klammersyntaks
echo "Dette fungerer: ($ arr [" tast "])";
// Virker
echo "Dette fungerer: ($ arr [4] [3])";
// Dette er feil av samme grunn som $ foo utenfor
// strenger. Det vil med andre ord fortsatt fungere.
// men siden PHP ser etter konstant foo først, vil dette kalle
// E_NOTICE nivåfeil (udefinert konstant).
ekko "Det er ikke riktig:($ arr [foo] [3]) ";
// Virker. Ved bruk av flerdimensjonale arrays internt
// strenger bruker alltid krøllete tannregulering
echo "Dette fungerer: ($ arr [" foo "] [3])";
// Virker.
ekko "Dette fungerer:". $ arr ["foo"] [3];
ekko "Dette fungerer også:($ obj -> verdier [3] -> navn) ";
ekko "Dette er verdien av variabelen etter navn$ navn: ($ ($ navn)) ";
ekko "Dette er verdien av variabelen etter navn som funksjonen getName () returnerer:($ (getName ())) ";
ekko "Dette er verdien av variabel ved navn som \ $ objekt-> getName () returnerer:($ ($ objekt -> getName ())) ";
// Fungerer ikke, utdata: Dette er hva getName () returnerer: (getName ())
ekko "Dette er hva getName () returnerer: (getName ())";
?>
Ved å bruke denne syntaksen er det også mulig å få tilgang til objektegenskaper innenfor strenger.
klasse foo (
var $ bar = "Jeg er bar." ;
}
$ foo = ny foo ();
$ bar = "bar";
$ baz = array ("foo", "bar", "baz", "quux");
echo "($ foo -> $ bar) \ n";
echo "($ foo -> ($ baz [1])) \ n";
?>
Resultatet av dette eksemplet:
Jeg er bar. Jeg er bar.
Kommentar:
Funksjoner, metodekall, statiske klassevariabler og klassekonstanter fungerer internt {$} siden PHP 5. Den angitte verdien vil imidlertid bli behandlet som et variabelnavn i samme kontekst som strengen den er definert i. Bruk av 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 gjerne A & W
echo "Jeg vil gjerne ($ (øl :: brus)) \ n";
// Dette fungerer også, utganger: I would like Alexander Keith "s
echo "Jeg vil gjerne ($ (øl :: $ ale)) \ n";
?>
Få tilgang til og endre et tegn i en streng
Tegn i strenger kan brukes og endres ved å definere deres offset fra begynnelsen av strengen, med start på null, i hakeparenteser etter strengen, for eksempel $ str. Tenk på en streng som en rekke tegn for dette formålet. Hvis du trenger å få eller erstatte mer enn 1 tegn, kan du bruke funksjonene substr () og substr_erstatt ().
Kommentar: siden PHP 7.1.0 negative offset-verdier støttes. De setter offset fra slutten av linjen. Tidligere negative forskyvninger forårsaket en nivåfeil E_MERKNAD mens du leser (returnerer en tom streng) heller E_ADVARSEL mens du skriver (forlater linjen uendret).
Kommentar: Et tegn i en streng kan også refereres ved hjelp av krøllete klammeparenteser, for eksempel $ str (42).
Merk følgende
Forsøk på å skrive til en off-line offset vil fylle linjen med mellomrom opp til den offset. Ikke-heltallstyper vil bli konvertert til heltall. Feil forskyvningstype vil forårsake 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 ble en NULL-byte tildelt i dette tilfellet.
Merk følgende
Strenger i PHP er interne arrays av byte. Som et resultat er det usikkert å få tilgang til eller endre en streng ved offset fra et multibyte-kodingssynspunkt, og bør bare utføres med strenger i enkeltbyte-kodinger som ISO-8859-1.
Kommentar: Fra og med PHP 7.1.0 forårsaker bruk av en tom indeks en fatal feil, tidligere, i et lignende tilfelle, ble en streng konvertert til en matrise uten forvarsel.
Eksempel # 12 Noen strengeksempler
// Få det første tegnet i strengen
$ str = "Dette er en test." ;
$ første = $ str [0];
// Få det tredje tegnet i strengen
$ tredje = $ str [2];
// Få det siste tegnet i strengen
$ str = "Dette er fortsatt en test." ;
$ siste = $ str [strlen ($ str) - 1];
// Endre det siste tegnet i linjen
$ str = "Se på havet";
$ str [strlen ($ str) - 1] = "e";
?>
Siden PHP 5.4 må forskyvningen i strengen spesifiseres enten som et heltall eller som en streng som inneholder tall, ellers vil det bli utstedt en advarsel. Tidligere forskyvningen spesifisert av linjen i skjemaet "foo", uten advarsler konvertert 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:
streng (1) "b" bool (true) streng (1) "b" bool (true) streng (1) "a" bool (true) streng (1) "b" bool (true)
Resultatet av å kjøre dette eksemplet i PHP 5.4:
streng (1) "b" bool (true) Advarsel: Ulovlig strengforskyvning "1.0" i /tmp/t.php på linje 7 streng (1) "b" bool (false) Advarsel: Ulovlig strengforskyvning "x" i / tmp / t.php på linje 9 streng (1) "a" bool (falsk) streng (1) "b" bool (falsk)
Kommentar:
Forsøk på å få tilgang til variabler av andre typer (unntatt arrays eller objekter som implementerer visse grensesnitt) ved å bruke eller {} 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.
De grunnleggende funksjonene er beskrevet i avsnittet om strengfunksjoner, og for avansert søk og erstatning, funksjonene til Perl-kompatible regulære uttrykk.
Konverterer til streng
Verdien kan konverteres til en streng ved hjelp av en cast (streng), eller funksjoner strval ()... I uttrykk hvor en streng er nødvendig, skjer konverteringen automatisk. Dette skjer når du bruker funksjonene ekko eller skrive ut, eller når verdien til en variabel sammenlignes med en streng. Ved å lese delene Typer og Typemanipulering i håndboken vil følgende gjøres 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 variabel til type "Gjenstand" i type streng den magiske metoden __toString brukes.
Betydning NULL konverterer alltid til en tom streng.
Som du kan se ovenfor, gir ikke direkte konvertering til en rekke arrays, objekter eller ressurser 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 verdiene i PHP kan konverteres til en streng for permanent lagring. Denne metoden kalles serialisering og kan gjøres ved hjelp av funksjonen serialiser ().
Konvertering av strenger til tall
Hvis strengen gjenkjennes som en numerisk verdi, bestemmes den resulterende verdien og typen som vist nedenfor.
Hvis strengen ikke inneholder noen av tegnene ".", "E" eller "E", og verdien av tallet er plassert innenfor området av heltall (definert PHP_INT_MAX), vil strengen bli gjenkjent som et heltall ( heltall). I alle andre tilfeller anses det som et flyttall ( flyte).
Verdien bestemmes av begynnelsen av strengen. Hvis strengen begynner 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. En eksponent er en "e" eller "E" etterfulgt av ett eller flere sifre.
$ foo = 1 + "10.5"; // $ foo er flyte (11,5)
$ foo = 1 + "-1.3e3"; // $ foo er flyte (-1299)
$ foo = 1 + "bob-1.3e3"; // $ foo er heltall (1)
$ foo = 1 + "bob3"; // $ foo er heltall (1)
$ foo = 1 + "10 små griser"; // $ foo er heltall (11)
$ foo = 4 + "10.2 små griser"; // $ foo er 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 strtod (3)-delen av Unix-dokumentasjonen.
Hvis du vil teste noen av eksemplene i denne delen, kopier og lim inn den og følgende linje for å se hva som skjer:
ekko "\ $ foo == $ foo; skriv:". gettype ($ foo). "
\ n ";
?>
Ikke forvent å få en tegnkode ved å konvertere den til et heltall (slik det for eksempel gjøres i C). For å konvertere tegn til deres ASCII-koder og omvendt, 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 =<<
SLUTT;
?>
Dette betyr ikke:
foo (<<
SLUTT;
);
// syntaksfeil, uventet ";"
?>
Uten semikolon fungerer det fint:
foo (<<
SLUTT
);
?>
3 år siden
Du kan bruke strenglignende rekke av røye (som C)
$ a = "String array test";
var_dump ($ a);
// Returstreng (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 være () -innebygd 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: ($ dette :: $ VAR)";
}
Offentlig funksjon siHelloConst () (
echo "hei: ($ dette :: 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én dollar=
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 ().
* foranstillede 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 i 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
// Lekeplassen vår
$ a=
3
; funksjon c($ a,
$ b) (komme tilbake$ a+
$ b; }
// Bruk // 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")-testen), brukes de resulterende numerikkene, ellers sammenlignes FULLE strenger tegn-for-tegn: var_dump("1.22"
>
"01.23"
);
// 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 ( Skrive ut "Dette er en$ frukt[
"a"] ";
// T_ENCAPSED_AND_WHITESPACE Du kan løse det på følgende måte: skrive ut"Dette er en$ frukt[
en]
"
;
// ta opp nøkkelen Det er ikke klart (i det minste for meg) hvorfor PHP feiltolker enkeltsitatet 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 ...? I det siste innlegget så vi på syntaksen til en betinget setning i PHP. Dette innlegget vil fokusere på operatørparenteser. Du vil møte dem hele tiden. Dette er det grunnleggende konseptet for ethvert programmeringsspråk. Wikipedia vil hjelpe oss med å svare på spørsmålet om hva som er operatørparenteser: Operatørbraketter- parenteser eller kommandoer som definerer i programmeringsspråket en blokk med kommandoer, oppfattet som en helhet, som én kommando. På Pascal-språket brukes konstruksjonen for å betegne operatørparenteser begynne…. slutt... På C-lignende språk (som inkluderer PHP), er operatørparentes beskrevet ved hjelp av symboler {…}
. De. med andre ord, flere kommandoer i parentes behandles som én kommando. Artikkelen om betingelser i PHP det var et eksempel:
$ b) (ekko "Variabel A er større enn B";) else (ekko "Variabel B er større enn A";)?> I dette eksemplet brukes operatørbrakettene 2 ganger. De rammer operatørene I dette eksemplet er bare 1 setning omsluttet i parentes, så det tilsvarer å skrive slik:
$ b) ekko "Variabel A er større enn B"; else ekko "Variabel B er større enn A"; ?> Syntaks: Hvis (betingelse) uttrykk 1; annet uttrykk 2; La oss si at vi vil at en annen linje skal vises på skjermen hvis betingelsen ikke er oppfylt. Vi vil også endre verdiene til variablene våre slik at nå $ a var> $ b... La oss endre koden vår:
$ b) ekko "Variabel A er større enn B."; else echo "Variabel B er større enn A."; echo "Ja...ja A er faktisk mindre enn B."; ?> Vi utfører ... Hva ser vi på skjermen: Variabel A er større enn B. Ja..ja A er faktisk mindre enn B. En feil har sneket seg inn her et sted. Som du allerede har gjettet, er hele poenget at siden vår tilstand er sann (a> b), blir koden utført: Ekko "Variabel A er større enn B."; I en gren ellers vi har bare 1 uttrykk: Ekko "Variabel B er større enn A."; Følgende uttrykk vil bli utført uavhengig av betingelsen. Som dette:
$ b) ekko "Variabel A er større enn B."; else echo "Variabel B er større enn A."; echo "Ja...ja A er faktisk mindre enn B."; ?> Nå bruker vi operatorparentesene og kombinerer de 2 uttrykkene i grenen ellers:
$ b) (ekko "Variabel A er større enn B.";) else (ekko "Variabel B er større enn A."; ekko "Ja..ja A er faktisk mindre enn B.";)?> Koden er blitt mye klarere. Nå PHP forstår at hvis betingelsen ($ a> $ b) ikke er oppfylt, skal 2 linjer skrives ut. Og hvis tilstanden er sann - bare én. Min du store råd- bruk alltid operatørbraketter, selv om du ikke trenger å kombinere flere operatører til en blokk. Faktum er at:
funksjon_expr($ v) (komme tilbake$ v; }
$ _expr=
"_expr";
definere("qwe",
"asd");
definere("zxc",
5
);
$ b=
4
;
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"
?>
var_dump("1.22.00"
>
"01.23.00"
);
// bool (sant)
var_dump("1-22-00"
>
"01-23-00"
);
// bool (sant)
var_dump((flyte)"1.22.00"
> (flyte)"01.23.00"
);
// bool (false)
?>
"en"=>
"eple",
"b"=>
"banan",
// etc
);
?>
vil definitivt falle i stykker.
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.
