IN pēdējā laikā diskusijas par PHP valodu par Habré vairāk attiecas uz dizaina iespējām sarežģītas sistēmas, kas nevar vien priecāties. Tomēr, apskatot duci atzītāko tīmekļa ietvaru (Zend Framework, Adept, CakePHP, CodeIgniter, LIMB, Symfony, MZZ un citus), biju patiesi pārsteigts, ka dažos atklāju būtiskus trūkumus no elementāras optimizācijas viedokļa. .

Lai šo tēmu padarītu tehniski orientētāku, rezultāti tiek pasniegti stingrākā formā, kas var nedaudz apgrūtināt uztveri.

Tātad, iesim... Uzdevums ir ārkārtīgi vienkāršs: veiciet eksperimentus par stīgu veidošanas ātrumu no apakšvirknēm vienpēdiņās un dubultpēdiņās. Principā šis jautājums joprojām būs aktuāls uz ilgu laiku stīgu apstrādes īpatnību dēļ PHP.

Ir daudz rakstu par pamata skriptu optimizāciju gan krievu, gan citās valodās. Tajā ir maz teikts par virknēm, taču tiek atzīmēts fakts, ka virknes dubultpēdiņās tiek “parsētas” mainīgajiem un kontroles rakstzīmēm (tāpat kā oficiālajā dokumentācijā). Pamatojoties uz to, ir loģiski pieņemt, ka virkņu izmantošana dubultpēdiņās darbosies nedaudz lēnāk nekā tās pašas darbības ar apakšvirknēm vienpēdiņās.

Papildus mainīgo aizstāšanai virknēs un mainīgo savienošanai ar apakšvirknēm, PHP ievieš vēl vismaz vienu veidu, kā ģenerēt virknes: darbu ar sprintf funkciju. Ir loģiski to pieņemt šī metode būs ievērojami zemāki par “standarta” nevajadzīgo funkciju izsaukuma un virkņu parsēšanas dēļ.

Vienīgais papildinājums, pirms es jums prezentēju testa skripta kodu: ir jāņem vērā 2 lietas iespējamie varianti darbs ar dubultpēdiņu virknēm: ņemot vērā vienkāršus un “progresīvus” kodēšanas stilus. Jums, iespējams, nevajadzētu pievērst uzmanību faktam, ka mainīgie atrodas rindu pašā sākumā - tie ir tikai piemēri:
$string = "$_SERVER["HTTP_HOST"] nav Uļjanovskas apgabala administrācija. Mēs mīlam krievu valodu un mums nepatīk tie, kas to runā..."
Un
$string = "($_SERVER["HTTP_HOST"]) nav Uļjanovskas apgabala administrācija. Mēs mīlam krievu valodu un mums nepatīk tie, kas tajā runā..."

Tests numur viens.
Nu, šķiet, ka visas atrunas ir izdarītas - ir pienācis laiks parādīt darba rezultātus. Avota kods var atrast testeri.

Ekrānuzņēmumos redzams, ka mana hipotēze neapstiprinājās. Vienīgais pareizais pieņēmums izrādījās par darbu ar stīgām caur sprintf. Ātrākās bija funkcijas, kas darbojas tieši ar dubultpēdiņām.

Īsi pārdomājot situāciju, skaidrojums nāca pats par sevi: visa būtība ir tāda, ka atsauces virkne, kurā tika veikta aizstāšana, ir pārāk īsa: parsētāja izeja caur šādu virkni ir vienkārša. Tomēr pat šeit ir skaidrs, ka mainīgā dabiskā aizstāšana virknē dod priekšrocības salīdzinājumā ar “uzlaboto stilu”.
Tas ir arī savienošanas pieejas vājums: ievietoto datu apjoms pārsniedz apakšvirkņu apjomu. No kurienes rodas pieskaitāmās izmaksas, varat izlasīt jau minētajā habratopā.

Tomēr pat šīs domas bija jāapstiprina. Tam bija nepieciešams otrs tests, mainot iespējamos minētos šādas neparedzamas (man) uzvedības iemeslus. Acīmredzot piektajā versijā ir daudz pielabots (atzīšos, PHP piektajā versijā veicu tikai 1 testu: šķērsot masīva elementus).

Tests numur divi.
Otrā hipotēze: atsauces virknes pagarināšana galu galā palielinās to testa funkciju darbības laika procentuālo daļu, kas saistītas ar virkņu veidošanu dubultpēdiņās, salīdzinot ar testa numura 1 rezultātiem. Teorētiski ir jāievēro tāda pati situācija. saistībā ar sprintf funkcijas darbību. Tas, pirmkārt, ir saistīts ar nepieciešamību parsēt virknes un tam veltītā laika palielināšanos. Situācijā ar apakšvirkņu savienošanu vienpēdiņās, manuprāt, tiks novērots aptuveni tāds pats rezultāts kā pirmajā testā, kas dos nelielu samazinājumu funkcijas pēdiņas_3() izpildes laika daļai salīdzinājumā ar izpildes laiku. no visa scenārija (bet ne veiktspējas pieaugumu).

Secinājumi patiesībā ir tikai pozitīvi un apstiprina hipotēzi. Nedaudz palielinot atsauces virkni, parādās liela slodze, kā rezultātā samazinās funkciju veiktspēja darbam ar pēdiņām un sprintf.

Arī pieņēmums par virknēm vienpēdiņās izrādījās pareizs: pirmajā testā 36,75% vietā, bet otrajā funkcija pēdiņas_3() aizņēma 33,76% no skripta izpildes laika.

Praktiskā vērtība.
Vienkāršā izteiksmē, abstrahējoties no datiem, mēs varam secināt: jo garāka ir rinda, kurā jāveic aizstāšana, visticamāk, ka savienošanas darbība tiks veikta ātrāk nekā mainīgā meklēšana dubultpēdiņās. Brīvprātīgie var mēģināt atlasīt nepieciešamos ievietošanas parametrus (mainīgo skaitu, atsauces virknes garumu, virkņu garumus mainīgajos), lai tie atbilstu izpildes laiku vienlīdzībai.

Tas arī viss, patiesībā. Atliek vien piebilst, ka programmēšanā nav nekādu nieku (es domāju tiem, kam patīk teikt “taupīt uz sērkociņiem” (c) Adelfs). Zinot šādus smalkumus un ņemot tos vērā, varat uzrakstīt kodu, kas tiks optimizēts visos tā līmeņos;)

PS:
Testi, kas veikti, izmantojot Zend Studio For Eclipse 6.0.0 (iekļauts atkļūdotājs + profilētājs).
PHP versija 5.2.5
Debian Linux OS

PPS:
Es būtu priecīgs, ja kāds publicētu savus šo testu rezultātus. Domāju, ka tas ļaus objektīvāk izvērtēt nepieciešamību izmantot vienu vai otru aizvietošanas metodi virknēs. Būšu pateicīgs arī veselīgu kritiku par prezentācijas stilu un dizainu.

Tipa virknes vērtības ir teksta virknes (saīsināti virknes). Virkne ir nulles vai vairāk rakstzīmju secība. Rakstzīmes ietver burtus, ciparus, pieturzīmes, īpašās rakstzīmes un telpas.

Virkni var definēt ar četriem dažādos veidos:

• dubultpēdiņas
• atsevišķi pēdiņas
• heredoc sintakse
• nowdoc sintakse

Virkne dubultpēdiņās

Virkne dubultpēdiņās:

Varat izmantot atsoļa secības divpēdiņās. Kontroles secība— tās ir īpašas rakstzīmes, kas paredzētas teksta izvades formatēšanai. PHP ir pieejamas šādas evakuācijas secības:

Galvenā dubultpēdiņu virkņu īpašība ir spēja apstrādāt mainīgos lielumus virknēs.

Dolāra zīme: \$";

Dubultās pēdiņās ievietotās virknes var saturēt vienas pēdiņas rakstzīmes:

Echo "Viens citāts: "";

Virkne atsevišķās pēdiņās (apostrofi)

Virkne atsevišķās pēdiņās:

$str = "Virkne"; echo "Vienu lielu rindiņu var sadalīt vairākās mazās rindās, lai būtu vieglāk lasīt.";

Atšķirībā no virknēm ar dubultpēdiņām un heredoc sintakse, mainīgie un vadības secības (ar vienu izņēmumu) ir iekļautas atsevišķi pēdiņas, netiek apstrādāti. Tas nozīmē, ka tie tiks interpretēti kā parastas virknes rakstzīmes:

$num = 10; echo "Numurs: $num
Dolāra zīme: \$";

Lai virknē, kas ietverta atsevišķās pēdiņās, varētu izmantot atsevišķas pēdiņas, tās ir jāatceļ, izmantojot atpakaļvērsto slīpsvītru (\"). Ja jums ir jāieraksta pati atpakaļvērstā slīpsvītra, tā ir jādublē (\\):

Atbalss "Izmantojiet \"atsevišķas\" pēdiņas iekšpusē"; atbalss "Aizmugursvītra: \\";

Vienpēdiņās ievietotās virknes var saturēt dubultpēdiņu rakstzīmes:

Echo "Dubultā citāts: "";

Heredoc sintakse

Heredoc sintakse ir alternatīvs veids virkņu rakstīšana.

Virkne, kas definēta, izmantojot Heredoc sintaksi, darbojas tāpat kā virkne, kas ievietota dubultpēdiņās. Atšķirība starp Heredoc un dubultpēdiņu virkni ir tāda, ka ar Heredoc nav nepieciešams izvairīties no dubultpēdiņām.

Heredoc sintakse sākas ar trim rakstzīmēm<<< , после которых должен быть указан произвольный идентификатор (назовём его открывающим). Идентификатор может быть указан как в двойных кавычках, так и без них. Tūlīt aiz identifikatora ir jāraksta jauna rindiņa, izņemot jaunu rindiņu, pretējā gadījumā radīsies kļūda. Tālāk nāk pats virknes saturs. Pēc virknes satura atsevišķā rindā jānorāda beigu identifikators (tāds pats kā pēc<<<). Перед ним и после него не должно быть никаких пробелов или других символов, за исключением точки с запятой. Если это правило нарушено, то считается, что закрывающий идентификатор отсутствует и будет вызвана ошибка:

<<

Nowdoc sintakse

Nowdoc sintakse, tāpat kā Heredoc, ir alternatīvs veids, kā rakstīt virknes.

Virkne, kas definēta, izmantojot Nowdoc sintaksi, darbojas tāpat kā virkne, kas ievietota atsevišķās pēdiņās. Atšķirība starp Nowdoc un vienpēdiņu virkni ir tāda, ka, izmantojot Nowdoc, nav nepieciešams izvairīties no vienpēdiņām.

Nowdoc sintakse ir līdzīga Heredoc sintakse, ar vienīgo atšķirību, ka sākuma identifikators ir jāiekļauj atsevišķās pēdiņās:

$num = 10; atbalss<<<"some_id" Число: $num some_id;

Mainīgo apstrāde virknēs

Ir divu veidu sintakse, lai apstrādātu mainīgos virknēs: vienkārši Un grūti.

Vienkārša sintakse- tas ir tad, kad mainīgā nosaukums tiek norādīts rindā tāds, kāds tas ir.

Kad tulks sastopas ar dolāra zīmi, tas sāk secīgi pārbaudīt, vai visas nākamās rakstzīmes ir derīgas rakstzīmes mainīgā nosaukumā. Tātad, lai izveidotu derīgu mainīgā nosaukumu, tajā ir jāietver pēc iespējas vairāk rakstzīmju:

$str = "Pasaule!"; atbalss "Sveiki $str";

Sarežģīta sintakse- tas ir tad, kad mainīgā nosaukums ir ievietots krokainās iekavās.

Tā kā, lai apstrādātu mainīgo rindā, tulks uztver pēc iespējas vairāk rakstzīmju, ir situācijas, kad tulks nevar patstāvīgi noteikt, kur beidzas mainīgā nosaukums:

$sport1 = "būs"; $sport2 = "pēda"; atbalss "Man patīk $sport1ball un $sport2ball";

Šajā gadījumā vēlamais rezultāts netiks sasniegts, jo tulks uzskatīs $sport1 par daļu no mainīgā nosaukuma $sport1bol, kas neeksistē.

Lai tulkam skaidri norādītu, kur beidzas mainīgā nosaukums, mainīgā nosaukums jāiekļauj cirtaini iekavās:

$sport1 = "būs"; $sport2 = "pēda"; echo "Man patīk ($sport1)bol un ($sport2)bol.";

Dolāra zīmi var novietot gan pirms, gan pēc krokainajām lencēm:

$sport1 = "būs"; $sport2 = "pēda"; echo "Man patīk $(sport1)bol un ($sport2)bol.";

Savienošana

Savienošana ir divu vai vairāku virkņu savienošana vienā lielākā virknē. Savienošana notiek, izmantojot savienošanas operatoru - . (punkts). Savienojot, katra nākamā rinda tiek pievienota iepriekšējās rindas beigām:

Jebkura veida vērtība, kas ir savienota ar virkni, tiks netieši pārveidota par virkni un pēc tam savienota:

"; echo "Numurs: " . 1; ?>

komentēt: PHP 7.0.0 64 bitu platformās nav sasniedzamu līnijas garuma ierobežojumu 32 bitu sistēmās, un iepriekšējās PHP versijās rindas nedrīkst būt lielākas par 2 GB (2147483647 baiti).

Sintakse

Virkni var definēt četros dažādos veidos:

• atsevišķi pēdiņas
• dubultpēdiņas
• nowdoc sintakse (kopš PHP 5.3.0)

Atsevišķi pēdiņas

Vienkāršākais veids, kā definēt virkni, ir ievietot to atsevišķās pēdiņās (rakstzīme " ).

Lai virknē izmantotu vienu pēdiņu, atkāpieties no tās ar atpakaļvērsto slīpsvītru ( \ ). Ja jums ir jāraksta pati atpakaļvērstā slīpsvītra, dublējiet to ( \\ ). Visi citi atpakaļvērstās slīpsvītras lietojumi tiks interpretēti kā parastas rakstzīmes: tas nozīmē, ka, ja mēģināt izmantot citas atsoļa secības, piemēram, \r vai \n, tie tiks izvadīti tādi, kādi tie ir, nevis īpašas darbības.

atbalss "šī ir vienkārša virkne";

atbalss "Var ievietot arī rindās
jaunrindas varonis, piemēram, šis,
Tas ir labi";

// Rezultāti: Arnolds reiz teica: "Es atgriezīšos"
atbalss "Kādu dienu Arnolds teica:" Es atgriezīšos.;

Atbalss "Vai izdzēsāt C:\\*.*?";

// Izejas: vai izdzēsāt C:\*.*?
echo "Vai izdzēsāt C:\*.*?" ;

// Izvadi: Tas netiks izvērsts: \n jauna rinda
atbalss "Tas netiks izvērsts: \n jauna rindiņa";

// Izejas: $expand un $vai nu mainīgie netiek izvērsti
atbalss "$expand un $vairs mainīgie nav izvērsti";
?>

Dubultās pēdiņas

Ja virkne ir ievietota dubultpēdiņās ("), PHP atpazīst šādas speciālās rakstzīmju atkāpšanās secības:

Tāpat kā ar virkni, kas ievietota atsevišķās pēdiņās, atspēkojot jebkuru rakstzīmi, tiks izvadīta arī pati atsoļa rakstzīme. Pirms PHP 5.1.1, atpakaļvērstā slīpsvītra \($var) netika publicēts.

Heredoc

Trešais veids, kā definēt virknes, ir izmantot heredoc sintakse: <<< . Pēc šī operatora jānorāda identifikators, pēc tam rindas plūsma. Pēc tam nāk pati rinda un pēc tam tas pats identifikators, aizverot ievietošanu.

Līnija vajadzētu sāciet ar beigu identifikatoru, t.i. tai jāparādās rindas pirmajā kolonnā. Turklāt identifikatoram ir jāievēro tie paši nosaukšanas noteikumi, kas attiecas uz visiem citiem PHP tagiem: tajā ir jābūt tikai burtciparu rakstzīmēm un pasvītrai, un tas nedrīkst sākties ar skaitli (pasvītras ir atļautas).

Uzmanību

Ir ļoti svarīgi atzīmēt, ka beigu identifikatora rindā nedrīkst būt citas rakstzīmes, izņemot semikolu ( ; ). Tas nozīmē, ka id nedrīkst būt ievilkts un ka pirms vai pēc semikola nedrīkst būt atstarpes vai tabulēšanas zīmes. Ir arī svarīgi saprast, ka pirmajai rakstzīmei pirms beigu identifikatora ir jābūt jaunās rindiņas rakstzīmei, kā to nosaka jūsu operētājsistēma. Piemēram, UNIX sistēmās, tostarp macOS, tas ir \n. Pēc noslēguma identifikatora nekavējoties jāsāk arī jauna rinda.

Ja šis noteikums tiek pārkāpts un noslēguma identifikators nav "tīrs", tiek pieņemts, ka trūkst noslēguma identifikatora un PHP turpinās to meklēt. Ja šajā gadījumā pareizais slēgšanas identifikators nekad netiek atrasts, tas izraisīs parsēšanas kļūdu ar rindas numuru skripta beigās.

1. piemērs Nepareizas sintakses piemērs

klase foo (
publiska $bar =<<bārs
EOT;
// atkāpe pirms noslēguma identifikatora nav atļauta
}
?>

2. piemērs Pareizas sintakses piemērs

klase foo (
publiska $bar =<<bārs
EOT;
}
?>

Heredoc nevar izmantot, lai inicializētu klases laukus.

Sākot ar PHP 5.3, šis ierobežojums attiecas tikai uz šeit dokumentiem, kas satur mainīgos.

Heredoc teksts darbojas tāpat kā virkne dubultpēdiņās, bez tām.

Tas nozīmē, ka šeit dokumentā nav jāizmanto pēdiņas, taču jūs joprojām varat izmantot iepriekš norādītās atsoļa secības.<<Mainīgie tiek apstrādāti, taču, izmantojot sarežģītus mainīgos lielumus heredoc iekšienē, jābūt tikpat uzmanīgiem kā strādājot ar virknēm.
3. piemērs Heredoc virknes definīcijas piemērs
$str =
līnijas piemērs,

aptver vairākas līnijas,
{
izmantojot heredoc sintaksi.
EOD;

Klase foo
{
var $foo ;
var $bar ;
}
}

Funkcija__construct()
$this -> foo = "Foo" ;

$this -><<$foo = jauns foo(); .
$name = "Vārds" ; atbalss .
Mans vārds ir "$name". Es ierakstu $foo -> foo
EOT;
?>

Tagad es secinu

($foo -> bārs [1])

Tam vajadzētu izvadīt lielo burtu "A": \x41

Mani sauc "Vārds". Es ierakstu Foo. Tagad es izvadu Bar2. Tam vajadzētu izvadīt lielo burtu "A": A

Ir iespējams arī izmantot heredoc sintaksi, lai nodotu datus caur funkciju argumentiem:
Kopš versijas 5.3.0 ir kļuvis iespējams inicializēt statiskos mainīgos un klases rekvizītus/konstantes, izmantojot heredoc sintaksi:
{
5. piemērs. Heredoc izmantošana statisko mainīgo inicializācijai<<// Statiskie mainīgie
funkcija foo()
}

statiska $josla =
Te nekā nav...
{
LABEL;<<// Konstantes/klases īpašības
klase foo

const BAR =<<Konstantes izmantošanas piemērs
klase foo
}
?>

FOOBAR;

Publisks $baz =

Lauka izmantošanas piemērs Sākot ar PHP 5.3.0, Heredoc identifikatoru varat ievietot arī pēdiņās: Tagaddoc deklarējot teksta bloku, kas nav paredzēts apstrādei.

Nowdoc ir norādīts ar tādu pašu secību <<< , kas tiek izmantots šeitdoc, bet šāds identifikators ir ievietots atsevišķās pēdiņās, piemēram, <<<"EOT" .

Visi nosacījumi, kas attiecas uz heredoc identifikatoriem, attiecas arī uz nowdoc, īpaši tie, kas attiecas uz beigu identifikatoru.

$this -><<<"EOD"
7. piemērs Nowdoc izmantošanas piemērs
Teksta piemērs,
aptver vairākas līnijas
izmantojot nowdoc sintaksi. Slīpsvītras vienmēr tiek traktētas burtiski,
piemēram, \\ un \".

EOD;

Šī piemēra izpildes rezultāts:

Piemērs tekstam, kas aptver vairākas rindiņas, izmantojot nowdoc sintaksi. Slīpsvītras vienmēr tiek traktētas burtiski, piemēram, \\ un \".

8. piemērs Nowdoc virknes citēšanas piemērs ar mainīgajiem
Te nekā nav...
{
/* Sarežģītāks piemērs ar mainīgajiem. */
publisks $foo ;

Klase foo
{
var $foo ;
publiskais $bar ;
}
}

Funkcija__construct()
$this -> foo = "Foo" ;

$this -><<<"EOT"
$this -> bar = masīvs("Stienis1" , "Stienis2" , "Bar3" );
Mans vārds ir "$name". Es drukāju $foo->foo.
Tagad es drukāju ($foo->bar).
EOT;
?>

EOD;

Tas nedrīkst izvadīt lielo "A": \x41

Mans vārds ir "$name". Es drukāju $foo->foo. Tagad es drukāju ($foo->bar). Tas nedrīkst izvadīt lielo "A": \x41

klase foo (
publiska $bar =<<<"EOT"
bārs
EOT;
}
?>

komentēt:

9. piemērs Statisko datu izmantošanas piemērs

PHP 5.3.0 tika pievienots nowdoc atbalsts.

Mainīgo apstrāde

Ja virkne ir norādīta dubultpēdiņās vai izmantojot heredoc, tajā esošie mainīgie tiek apstrādāti. Ir divu veidu sintakse: vienkārša un sarežģīta. Vienkārša sintakse ir vienkāršāka un ērtāka. Tas ļauj apstrādāt mainīgo, masīva vērtību ( masīvs) vai objekta īpašības (

objektu

) ar minimālu piepūli.

Sarežģītu sintaksi var identificēt pēc krokainajām iekavām, kas aptver izteiksmi. $ Vienkārša sintakse

Ja tulks sastopas ar dolāra zīmi (

), tas tver pēc iespējas vairāk rakstzīmju, lai izveidotu derīgu mainīgā nosaukumu. Ja vēlaties norādīt vārda beigas, iekļaujiet mainīgā nosaukumu krokainās iekavās.

$sula = "ābols" ;
echo "Viņš dzēra $ sulas sulu." . PHP_EOL ;

// Nepareizi. "s" ir derīga rakstzīme mainīgā nosaukumam, bet mainīgā nosaukums ir $sula.
atbalss "Viņš dzēra sulu, kas pagatavota no $ sulām." ;
?>

EOD;

// Pareizi. Mainīgā nosaukuma beigas ir stingri norādītas, izmantojot iekavās:

atbalss "Viņš dzēra sulu no $( sulas ) s." ; Ir divu veidu sintakse: vienkārša un sarežģīta. Viņš dzēra ābolu sulu. Viņš dzēra sulu, kas pagatavota no . Viņš dzēra kādu sulu no āboliem. masīvs Masīva elements ( ] ) iezīmē indeksa definīcijas beigas. Uz objektu īpašībām attiecas tie paši noteikumi, kas uz vienkāršiem mainīgajiem.

10. piemērs Vienkāršs sintakses piemērs

define ("KOOLAID" , "koolaid1" );
$sulas = array("ābols" , "apelsīns" , "koolaid1" => "violeta" );

echo "Viņš dzēra dažas $sulas [ 0 ] sulas." . PHP_EOL ;
echo "Viņš dzēra dažas $sulas [ 1 ] sulas." . PHP_EOL ;
echo "Viņš dzēra dažas $sulas [ koolaid1 ] sulas." . PHP_EOL ;

klases cilvēki (
publiskais $džons = "Džons Smits" ;
publisks $ Džeina = "Džeina Smita" ;
publiskais $roberts = "Roberts Paulsens" ;

Publisks $smith = "Smits" ;
}

$cilvēki = jauni cilvēki();

echo "$cilvēki -> Džons izdzēra $sulas [ 0 ] sulu." . PHP_EOL ;
echo " $cilvēki -> Džons pēc tam pasveicināja $cilvēkus -> Džeinu." . PHP_EOL ;
echo "$cilvēki -> Džona sieva sveicināja $cilvēkus -> robertu." . PHP_EOL;
echo " $cilvēki -> roberts sasveicinājās ar diviem $cilvēkiem -> smiths ." ; // Nedarbosies
?>

EOD;

Viņš dzēra ābolu sulu. Viņš dzēra apelsīnu sulu. Viņš dzēra purpursarkano sulu. Džons Smits dzēra ābolu sulu. Pēc tam Džons Smits pasveicināja Džeinu Smitu. Džona Smita sieva sveicināja Robertu Paulsenu.

PHP 7.1.0 ir pievienots atbalsts negatīvs skaitliskie indeksi.

11. piemērs Negatīvie skaitliskie indeksi

$string = "virkne" ;
atbalss "Raksturs indeksā -2 ir vienāds ar$string [- 2 ]." , PHP_EOL ;
$string [- 3 ] = "o" ;
atbalss "Mainot rakstzīmi pozīcijā -3 uz "o", tiek iegūta šāda rinda:$string." , PHP_EOL;
?>

EOD;

Rakstzīme ar indeksu -2 ir vienāda ar n. Mainot rakstzīmi pozīcijā -3 uz "o", tiek iegūta šāda rinda: spēcīga

Sarežģītākam darbam izmantojiet sarežģītu sintaksi.

Sarežģīta (cirtainā) sintakse

To sauc par sarežģītu nevis tāpēc, ka to būtu grūti saprast, bet gan tāpēc, ka ļauj izmantot sarežģītus izteicienus.

Jebkurš skalārs mainīgais, masīva elements vai objekta rekvizīts, kas kartēts ar virkni, var tikt attēlots virknē, izmantojot šo sintaksi. Vienkārši uzrakstiet izteiksmi tādā pašā veidā, kā to darītu ārpus līnijas, un pēc tam ietiniet to { Un } . Kopš { nevar izvairīties, šī sintakse tiks atpazīta tikai tad, kad $ seko tieši { . Izmantot {\$ drukāt {$ .

Daži ilustratīvi piemēri:
// Rādīt visas kļūdas

kļūdu_ziņošana (E_ALL);

$lieliski = "lieliski" ;
// Nedarbojas, iznāk: tas ir (lieliski)

echo "Tas ir ( $lieliski )" ;
// Darbi, iznākumi: Tas ir lieliski

echo "Tas ir ( $lieliski ) " ;
atbalss // Darbi“Šis laukums ir plats

( $kvadrāts -> platums ) 00 centimetri." ;
echo "Tas darbojas: ( $arr [ "key" ]) " ;

echo "Tas ir ( $lieliski ) " ;
echo "Tas darbojas: ( $arr [ 4 ][ 3 ]) " ;

// Tas nav derīgs tā paša iemesla dēļ, kā $foo ārpus
// rindas. Citiem vārdiem sakot, tas joprojām darbosies,
// bet tā kā PHP vispirms meklē konstantu foo, tas izraisīs
// līmeņa kļūda E_NOTICE (nenodefinēta konstante).
atbalss "Tas ir nepareizi:( $arr [ foo ][ 3 ]) " ;

// Darbi. Izmantojot daudzdimensiju masīvus iekšēji
// līnijās vienmēr tiek izmantotas cirtainas breketes
echo "Tas darbojas: ( $arr [ "foo" ][ 3 ]) " ;

// Darbi.
echo "Tas darbojas: " . $arr [ "foo" ][ 3 ];

atbalss "Tas arī darbojas:( $obj -> vērtības [ 3 ]-> nosaukums ) " ;

atbalss "Šī ir nosauktā mainīgā vērtība$nosaukums : ($( $nosaukums )) " ;

atbalss "Šī ir mainīgā nosaukuma vērtība, ko atgriež getName():($( getName ())) " ;

atbalss "Šī ir mainīgā vērtība pēc nosaukuma, ko \$object->getName() atgriež:($( $object -> getName ())) " ;

// Nedarbojas, izvada: Tas ir tas, ko getName() atgriež: (getName())
atbalss "Tas ir tas, ko getName() atgriež: (getName())";
?>

Izmantojot šo sintaksi, virknēs ir iespējams piekļūt arī objekta rekvizītiem.

klase foo (
var $bar = "Es esmu bārs." ;
}

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

EOD;

Es esmu bārs. Es esmu bārs.

komentēt:

Funkcijas, metožu izsaukumi, statiskie klases mainīgie un klases konstantes darbojas iekšēji {$} , sākot ar PHP 5. Tomēr norādītā vērtība tiks uzskatīta par mainīgā nosaukumu tajā pašā kontekstā kā rinda, kurā tā ir definēta. Izmantojot atsevišķas cirtainas lencēm ( {} ) nedarbosies, lai piekļūtu funkciju, metožu, klases konstantu vai statisko klases mainīgo vērtībām.

Daži ilustratīvi piemēri:
// Rādīt visas kļūdas

klases alus (
const bezalkoholiskais dzēriens = "sakņu alus" ;
public static $ale = "ipa" ;
}

$rootbeer = "A & W" ;
$ipa = "Aleksandrs Kīts" ;

// Tas darbojas, iznāk: Es gribētu A & W
echo "Es gribētu ($( alus :: softdrink )) \n" ;

// Tas arī darbojas, iznāk: I would like Alexander Keith's
echo "Es gribētu ($( alus :: $ale )) \n" ;
?>

Piekļuve rakstzīmei virknē un tās maiņa

Rakstzīmes virknēs var izmantot un modificēt, norādot to nobīdi no virknes sākuma, sākot no nulles, kvadrātiekavās aiz virknes, piemēram, $str . Padomājiet par virkni šim nolūkam kā rakstzīmju masīvu. Un Ja jums ir jāiegūst vai jāaizstāj vairāk nekā 1 rakstzīme, varat izmantot funkcijas.

komentēt: Sākot ar PHP 7.1.0, tiek atbalstītas negatīvās nobīdes vērtības. Tie norāda nobīdi no rindas beigām. Iepriekš negatīvās nobīdes izraisīja līmeņa kļūdu E_NOTICE lasot (atgriežot tukšu virkni) vai E_BRĪDINĀJUMS

komentēt: rakstot (rindu atstājot nemainītu).

Uzmanību

Rakstzīmei virknē var piekļūt arī, izmantojot krokainas figūriekavas, piemēram, $str(42) . lasot (atgriežot tukšu virkni) vai Mēģinot rakstīt nobīdi aiz līnijas robežām, virkne tiks papildināta ar atstarpēm līdz šai nobīdei. Veidi, kas nav veseli skaitļi, tiks pārveidoti par veseliem skaitļu veidiem.

Uzmanību

Nepareizs nobīdes veids izraisīs līmeņa kļūdu

komentēt: .

Tiek izmantota tikai piešķirtās virknes pirmā rakstzīme.

Sākot ar PHP 7.1.0, tukšas virknes piešķiršana radīs fatālu kļūdu. Iepriekš šajā gadījumā tika piešķirts nulles baits (NULL).
PHP virknes ir iekšēji baitu masīvi. Līdz ar to piekļuve virknei ar nobīdi vai tās modificēšana nav droša vairāku baitu kodēšanai, un to drīkst darīt tikai ar virknēm viena baita kodējumos, piemēram, ISO-8859-1.
Kopš PHP 7.1.0 tukša indeksa izmantošana rada fatālu kļūdu, šajā gadījumā virkne tika pārveidota par masīvu bez brīdinājuma.

12. piemērs Daži virkņu piemēri
// Iegūstiet virknes pirmo rakstzīmi

$str = "Šis ir tests." ;
$pirmais = $str [ 0 ];
// Iegūstiet virknes trešo rakstzīmi

$trešais = $str [ 2 ];
// Iegūstiet virknes pēdējo rakstzīmi
$str = "Šis joprojām ir tests." ;

?>

$last = $str [ strlen ($str ) - 1]; // Mainiet rindas pēdējo rakstzīmi$str = "Paskaties uz jūru" ; 0 .

$str [ strlen ($str )- 1 ] = "e" ;

Sākot ar PHP 5.4, nobīde virknē ir jānorāda kā vesels skaitlis vai virkne, kas satur ciparus, pretējā gadījumā tiks parādīts brīdinājums. Iepriekš nobīde, ko sniedza virkne, piemēram

"foo"
, bez brīdinājuma tika pārveidots par

13. piemērs: atšķirības starp PHP 5.3 un 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" ]));

komentēt:

Mēģinājums piekļūt cita veida mainīgajiem (izņemot masīvus vai objektus, kas īsteno noteiktas saskarnes), izmantojot vai {} klusībā atgriezīsies NULL.

komentēt:

PHP 5.5 pievienoja atbalstu piekļuvei rakstzīmēm virknes literāļos, izmantojot sintaksi vai {} .

Virkņu modificēšanai ir daudz noderīgu funkciju.

Pamatfunkcijas ir aprakstītas sadaļā par virkņu funkcijām, bet izvērstās meklēšanas un aizstāšanas gadījumā - ar Perl saderīgas regulārās izteiksmes funkcijas.

Pārvērst par virkni

Vērtību var pārvērst virknē, izmantojot cast (virkne), vai funkcijas strval(). atbalss vai Izteiksmēs, kurās ir nepieciešama virkne, konvertēšana notiek automātiski. Tas notiek, kad izmantojat funkcijas drukāt.

, vai ja mainīgā vērtība tiek salīdzināta ar virkni. Izlasot rokasgrāmatas sadaļas “Tipi” un “Manipulācijas ar tipiem”, turpmākais būs skaidrāks. Skatīt arī settype() Masīvi vienmēr tiek pārveidoti par virkni Ir divu veidu sintakse: vienkārša un sarežģīta."Masīvs" atbalss vai Izteiksmēs, kurās ir nepieciešama virkne, konvertēšana notiek automātiski., tāpēc jūs nevarat parādīt masīva saturu ( ), izmantojot lai redzētu, ko tas satur. Lai skatītu vienu elementu, izmantojiet kaut ko līdzīgu

echo $arr["foo"] . Tālāk skatiet padomus, kā parādīt/skatīt visu saturu. Lai pārveidotu tipa mainīgo "Objekts" tipā

stīga NULL Tiek izmantota maģiskā metode __toString.

Nozīme vienmēr tiek pārveidots par tukšu virkni. Un Kā redzat iepriekš, masīvu, objektu vai resursu tieša konvertēšana virknē nesniedz nekādu noderīgu informāciju par pašām vērtībām, izņemot to veidus..

Labāks veids, kā izvadīt vērtības atkļūdošanai, ir izmantot funkcijas print_r().

var_dump()

Lielāko daļu PHP vērtību var pārveidot par virkni pastāvīgai glabāšanai. Šo metodi sauc par serializāciju, un to var veikt, izmantojot funkciju

serializēt () Virkņu pārvēršana skaitļos Ja virkne tiek atpazīta kā skaitliska vērtība, iegūto vērtību un veidu nosaka šādi. Ja virknē nav nevienas no rakstzīmēm ".", "e" vai "E" un skaitļa vērtība ir veselu skaitļu robežās (definēta PHP_INT_MAX ), virkne tiks atpazīta kā vesels skaitlis ().

Vērtību nosaka virknes sākums. Ja rinda sākas ar derīgu skaitlisku vērtību, šī vērtība tiks izmantota. Pretējā gadījumā vērtība būs 0 (nulle). Derīga skaitliska vērtība ir viens vai vairāki cipari (kas var saturēt decimālzīmi), pirms kuriem pēc izvēles ir zīme, kam seko neobligāts eksponents. Eksponents ir "e" vai "E", kam seko viens vai vairāki cipari.

$foo = 1 + "10,5" ; // $foo ir pludiņš (11.5)
$foo = 1 + "-1.3e3" ; // $foo ir pludiņš (-1299)
$foo = 1 + "bob-1.3e3" ; // $foo ir vesels skaitlis (1)
$foo = 1 + "bob3" ; // $foo ir vesels skaitlis (1)
$foo = 1 + "10 mazas cūkas" ; // $foo ir vesels skaitlis (11)
$foo = 4 + "10,2 mazi cūciņas" ; // $foo ir pludiņš (14.2)
$foo = "10.0 cūkas" + 1 ; // $foo ir peldošs (11)
$foo = "10,0 cūkas" + 1,0 ; // $foo ir peldošs (11)
?>

Lai iegūtu papildinformāciju par šo konvertēšanu, skatiet sadaļu par strtod(3) Unix dokumentācijā.

Ja vēlaties pārbaudīt kādu no šajā sadaļā minētajiem piemēriem, kopējiet un ielīmējiet to un šo rindiņu, lai redzētu, kas notiek:

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

Negaidiet, ka iegūsit rakstzīmes kodu, pārvēršot to veselā skaitlī (kā tas tiek darīts, piemēram, C). Lai pārveidotu rakstzīmes to ASCII kodos un atpakaļ, izmantojiet funkcijas ord() Un chr().

Virknes veida ieviešanas informācija

pirms 7 gadiem

Dokumentācijā nav minēts, bet beigu semikolu heredoc beigās faktiski interpretē kā īstu semikolu, un tādējādi dažreiz tas rada sintakses kļūdas.

$foo =<<abcd
BEIGAS;
?>

Tas nenodrošina:

foo (<<abcd
BEIGAS;
);
// sintakses kļūda, neparedzēta ";"
?>

Bez semikola tas darbojas labi:

foo (<<abcd
BEIGAS
);
?>

pirms 3 gadiem

Varat izmantot virkni, piemēram, zīmju masīvu (piemēram, C)

$a = "Virku masīva pārbaude";

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

var_dump($a);
// Atgriešanas virkne(1) "S"

// -- Ar masīva apraidi --
var_dump((masīvs) $a);
// Atgriezt masīvu(1) ( => string(17) "String array test")

var_dump((masīvs) $a);
// Atgriešanas virkne (17) "S"

Norihiori

pirms 15 gadiem

Varat izmantot sarežģīto sintaksi, lai virknē ievietotu gan objekta rekvizītu, gan objekta metožu vērtību. Piemēram...
klases ieskaite(
publiskais $ viens = 1 ;
publiskā funkcija divi() (
atgriešanās 2;
}
}
$test = new Test();
echo "foo ( $test -> one ) bar ( $test -> two ()) " ;
?>
Izvadīs "foo 1 bar 2".

Tomēr jūs nevarat to izdarīt visām vērtībām savā nosaukumvietā. Klases konstantes un statiskās īpašības/metodes nedarbosies, jo kompleksā sintakse meklē "$".
klases ieskaite(
const ONE = 1;
}
echo "foo (Test::ONE) bar" ;
?>
Tas izvadīs "foo (Test::one) bar". Konstantes un statiskās īpašības liek jums izjaukt virkni.

pirms 3 gadiem

Ņemiet vērā, ka saskaņā ar "virknes pārvēršanu skaitļos":

Ja ("123abc" == 123 ) atbalss "(intstr == int) nepareizi pārbauda kā patiesu.";

// Tā kā viena puse ir skaitlis, virkne tiek nepareizi pārveidota no intstr uz int, kas pēc tam atbilst testa numuram.

// Patiess visiem nosacījumiem, piemēram, if un switch priekšrakstiem (iespējams, arī while cilpas)!

// Tas varētu būt milzīgs drošības risks, pārbaudot/izmantojot/saglabājot lietotāja ievadi, gaidot un pārbaudot tikai veselu skaitli.

// Šķiet, ka vienīgais labojums ir tas, ka 123 ir virkne kā "123", tāpēc konvertēšana nenotiek.

?>

pirms 6 gadiem

Virknēs esošās nulles (mazākais pārsteigums) netiek uzskatītas par oktālām.
Apsveriet:
$x = "0123" + 0;
$y = 0123 + 0;
echo "x ir $x, y ir $y"; //drukā "x ir 123, y ir 83"
citiem vārdiem sakot:
* pirmās nulles ciparu literāļos avota kodā tiek interpretētas kā "oktāls", sk. strtol ().
* sākuma nulles virknēs (piemēram, lietotāja iesniegtie dati), kad (netieši vai tieši) tiek nodoti veselam skaitlim, tiek ignorētas un tiek uzskatītas par decimāldaļām, sk. strtod().

pirms 10 gadiem

Šis ir vienkāršs uzlaušanas veids, kas ļauj dubultpēdiņās un heredocs saturēt patvaļīgas izteiksmes cirtaini iekavas sintaksē, tostarp konstantes un citus funkciju izsaukumus:

// Hack deklarācija
funkcija _expr ($v ) (atgriež $v ; )
$_expr = "_expr" ;

// Mūsu rotaļu laukums
define("qwe" , "asd");
definēt("zxc", 5 );

$a= 3 ;
$b= 4 ;

funkciju c($a, $b) (atgriezties$a+ $b; }

//Lietošana
atbalss"iepriekš{ $_expr(1 + 2 )} izlikt\n"; // izvada "pre 3 post"
atbalss"iepriekš{ $_expr(qwe)} izlikt\n"; // izvada "pre asd post"
atbalss"iepriekš{ $_expr(c($a, $b)+ zxc* 2 )} izlikt\n"; // izvada "pre 17 post"

// Vispārējā sintakse ir ($_expr(...))
?>

pirms 2 gadiem

Es domāju, ka būtu noderīgi pievienot šo komentāru, lai informācija vismaz parādītos pareizajā PHP vietnes lapā.

Ņemiet vērā: ja plānojat izmantot dubultpēdiņu virkni ar asociatīvo atslēgu, iespējams, tiks parādīta kļūda T_ENCAPSED_AND_WHITESPACE. Daži to uzskata par vienu no mazāk acīmredzamiem kļūdu ziņojumiem.

Izteiciens, piemēram:

$auglis=masīvs(
"a"=> "ābols",
"b"=> "banāns",
// utt
);

Drukāt "Šis ir a$auglis[ "a"]"; // T_ENCAPSED_AND_WHITESPACE
?>

noteikti sabruks gabalos.

Varat to atrisināt šādi:

Izteiksmēs, kurās ir nepieciešama virkne, konvertēšana notiek automātiski."Šis ir a$auglis[ a] " ; // noņemiet atslēgu
Izteiksmēs, kurās ir nepieciešama virkne, konvertēšana notiek automātiski."Šis ir a${ augļus[ "a"]} " ; // Sarežģīta sintakse
Izteiksmēs, kurās ir nepieciešama virkne, konvertēšana notiek automātiski."Šis ir a{ $auglis[ "a"]} " ; // Sarežģītas sintakses variācijas
?>

Es personīgi dodu priekšroku pēdējai variācijai, jo tā ir dabiskāka un tuvāka tam, kāda būtu izteiksme ārpus virknes.

Nav skaidrs (vismaz man), kāpēc PHP nepareizi interpretē vienu pēdiņu izteiksmē, bet es domāju, ka tam ir kāds sakars ar faktu, ka pēdiņas nav vērtību virknes daļa - kad virkne jau tiek parsēta, pēdiņas vienkārši traucēt...?

pirms 2 gadiem

Abiem vajadzētu strādāt :(

klasēTestēšana{
publiska statiska$VAR= "statisks";
publisks const VAR ="konsts";

Publiskā funkcija saki Sveiki, Statiski() {
atbalss"labdien:{ $this:: $VAR} " ;
}

Publiskā funkcija saki HelloConst() {
atbalss"labdien:{ $this::VAR)" ; //Parsēšanas kļūda: sintakses kļūda, neparedzēta ")", gaida "["
}
}

$obj= jaunsTestēšana();
$obj-> saki Sveiki, Statiski();
$obj-> saki HelloConst();

pirms 3 gadiem

Kaut ko es piedzīvoju, kas, bez šaubām, kādam palīdzēs. . .
Manā redaktorā tas sintakse izcels HTML un $commentu:

$html =<<<"EOD"
$komentārs
līnijas piemērs,

Izmantojot šo, tiek parādīta viena krāsa:

$html =<<$komentārs
līnijas piemērs,

padarot to daudz vieglāku darbu

pirms 11 gadiem

Lai saglabātu prātu, nelasi iepriekšējos komentārus par datumiem ;)

Ja abas virknes var pārveidot par skaitļiem (("$a" > "$b") testā), tad tiek izmantoti iegūtie skaitļi, pretējā gadījumā FULL virknes tiek salīdzinātas pa zīmēm:

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((peldēt)"1.22.00" > (peldēt)"01.23.00" ); //bool(false)
?>

(PHP 4, PHP 5, PHP 7)

str_replace — Aizstāj visus meklēšanas virknes gadījumus ar aizstājējvirkni

Apraksts

Šī funkcija atgriež virkni vai masīvu ar visiem meklēšanas gadījumiem priekšmetā, kas aizstāts ar aizstāt.

Ja nav nepieciešami sarežģīti meklēšanas/aizstāšanās noteikumi (piemēram, regulāras izteiksmes), ieteicams izmantot šo funkciju preg_replace().

Parametru saraksts

Ja meklēšana un aizstāšana ir masīvi, tad str_replace() izmanto katru vērtību no atbilstošā masīva, lai meklētu un aizstātu tēmu . Ja aizstāšanas masīvā ir mazāk elementu nekā meklēšanā , tukšā virkne tiks izmantota kā aizstājējvirkne atlikušajām vērtībām.

Ja meklēšana ir masīvs un aizstāšana ir virkne, šī aizstāšanas virkne tiks izmantota katram meklēšanas masīva elementam. Apgrieztajam gadījumam nav jēgas.

Ja meklēšana vai aizstāšana ir masīvi, to elementi tiks apstrādāti no pirmā līdz pēdējam. Meklēšanas vērtība, kas pazīstama arī kā adata

(adata). Varat izmantot masīvu vairākām meklēšanas vērtībām.

Aizstāt

Aizstāšanas vērtība tiks izmantota, lai aizstātu meklēšanas vērtības. Varat izmantot masīvu vairākām vērtībām.

Priekšmets Virkne vai masīvs, kurā tiek veikta meklēšana un aizstāšana, kas pazīstama arī kā siena kaudze

(siena kaudze).

Ja priekšmets ir masīvs, tad katram priekšmeta elementam tiks veikta meklēšana un aizstāšana, un funkcijas rezultāts arī būs masīvs.

Atgriešanās vērtības

Šī funkcija atgriež virkni vai masīvu ar aizstātām vērtībām.

Piemēri

1. piemērs Lietošanas piemēri str_replace()

// piešķir
$bodytag = str_replace ("%body%" , "melns" , " " );

// piešķir: Hll Wrld f PHP
$patskaņi = masīvs("a" , "e" , "i" , "o" , "u" , "A" , "E" , "I" , "O" , "U" );
$onlyconsonants = str_replace ($patskaņi , "" , "Hello World of PHP" );

// piešķir: Katru dienu jāēd pica, alus un saldējums
$frāze = "Jums vajadzētu ēst augļus, dārzeņus un šķiedrvielas katru dienu.";
$veselīgs = array("augļi" , "dārzeņi" , "šķiedrvielas" );
$yummy = array("pica" , "alus" , "saldējums");

$jaunfrāze = str_aizvietot($veselīgs, $garšīgs, $frāze);

// piešķir: 2
$str = str_aizvietot ("ll" , "" , "laba, mollija jaunkundze!" , $count );
echo $count ;
?>

2. piemērs Iespējamo triku piemēri ar str_replace()

// Aizstāšanas pasūtījums
$str = "1. rindiņa\n2. rindiņa\r3. rindiņa\r\n4. rindiņa\n";
$order = masīvs("\r\n" , "\n" , "\r" );
$aizstāt = "
" ;

// Vispirms apstrādā \r\n, lai izvairītos no to aizstāšanas.
echo $newstr = str_aizvietot ($order, $aizstāt, $str);

// Drukā F, jo A aizstāj ar B, tad B ar C un tā tālāk...
// Rezultātā E tiks aizstāts ar F, jo aizstāšana notiek no kreisās puses uz labo.
$meklēšana = masīvs("A" , "B" , "C" , "D" , "E" );
$aizstāt = masīvs("B" , "C" , "D" , "E" , "F" );
$subject = "A" ;
echo str_replace ($meklēt, $aizstāt, $subject);

// Rezultāti: applerootrootnut (iepriekš minētā iemesla dēļ)
$burti = array("I" , "about" );
$auglis = masīvs("ābols" , "rieksts");
$text = "Es esmu par" ;
$izeja = str_replace ($burti, $auglis, $teksts);
atbalss $izeja ;
?>

Piezīmes

komentēt: Šī funkcija ir droša, lai apstrādātu datus binārā formā.

Brīdinājums

Piezīme par nomaiņas procedūru

Jo str_replace() veic aizstāšanu no kreisās puses uz labo, tad, izmantojot vairākas aizstāšanas, var aizstāt iepriekš ievietoto vērtību ar citu.

komentēt:

Skatiet arī piemērus šajā lapā. Šī funkcija ir reģistrjutīga. Izmantot str_ireplace()

reģistrjutīgai nomaiņai.

Tabulas:
C_id | Uzņēmums | Atrašanās vieta
1 | LLC Meklēt | Kudykino laukums 15/3
2 | AS Elita | Sluņisvaļinska 133/7

3 | OJSC Pyschpyshch | Soldatodachestroyskoe 404
Remonta veids (remonta_veidi)
r_id | Remonta veidi |
1 | Āmurs + naglas
2 | Skaistuma vadīšana

3 | Kapitāls remonts
Pasūtījumu saraksts (saraksts)
l_id | Kurš | Kas nepieciešams | Laiks | Operatora komentārs
1 | 1 | 2 | %timestamp% | %operator_text%
2 | 2 | 1 | | %text%

3 | 3 | 2 | | %text%
Tabulā Nr.1 ​​ir iekļauts klientu saraksts.
Tabulā Nr.3 ir saraksts ar aktuālajiem pasūtījumiem operatīvajām komandām. Šī tabula tiek regulāri atjaunināta, un tās aizpildīšanai tiek izmantota tīmekļa veidlapa. Tā kā pasūtījumu ienāk diezgan daudz, tabulā tiek ievadīti ieraksti klienta ID un pakalpojuma veidā.

Faktiski problēma ir tā, ka trešā tabula ir jāparāda tīmekļa veidlapā “pasūtījuma atlase”, un ID vietā ir jāaizstāj atbilstošie lauki no citām kolonnām.

Kods:
$query = "ATLASĪT * NO saraksta";
$rezultāts = mysql_query($query);
while($row=mysql_fetch_array($result. // ņemt rezultātus no katras rindas
( atbalss "";// izvada datus
}

CREATE TABLE "table_name" ("id" int(255) NOT NULL AUTO_INCREMENT, "saraksta" teksts (80) NOT NULL, PRIMARY KEY("id".

INSERT INTO "table_name" ("saraksts") VALUES ("bla-bla")

labākā atbilde $vaicājums =
"
atlasīt uzņēmumus.Uzņēmums, remonta_veidi.Remonta_veidi, saraksts.komentārs_l
no saraksta
iekšējie pievienoties uzņēmumiem
sarakstā.Kas = uzņēmumi.c_id
iekšējā savienojuma labošanas_veidi
sarakstā."Kas nepieciešams" = remonta_veidi.r_id
";