Kumusta, kahapon ay pinag-aralan namin kung paano mo mahahati ang isang string at makakuha ng array mula dito. Ngayon dinadala ko sa iyong pansin ang kabaligtaran na pag-andar, sa tulong na magagawa natin i-convert ang array sa string. Ito ang tinatawag implode function.

Ang prinsipyo ng pagpapatakbo ng pagpapaandar na ito ay katulad ng nauna, ngunit titingnan natin ito gamit ang isang halimbawa: $array = array() ;
"Pangalan ko", "pangalan", "Denis" $string = sumabog(;
" ", $array) echo;
?>

$string Gumawa kami ng array na may tatlong elemento, at gamit implode function ginawa itong isang string. Ang function na ito ay maaaring tumagal ng dalawang parameter. Ang una ay opsyonal at nangangahulugan kung anong delimiter ang ilalapat sa pagitan ng mga elemento ng array. Kung hindi tinukoy ang parameter na ito, ang mga elemento ng array ay paghihiwalayin ng espasyo bilang default. At ang pangalawang parameter ay tumutukoy sa array mismo, na mako-convert sa isang string. Ito ang lahat ng mga parameter na sinusuportahan ng function na pinag-aaralan. Bilang resulta ng pagsasagawa ng function, matatanggap mo ang string (Ang pangalan ko ay Denis). Kung tinukoy namin ang isang kuwit bilang isang separator, ang magiging resulta ay (Ang pangalan ko ay Denis). Sa tingin ko ay walang mga problema sa pag-aaral ng function na ito, at magagamit mo ito sa iyong sarili kapag

paggawa ng iyong mga website

. Ito ay nagtatapos sa artikulong ito, tulad ng nakikita mo, ito ay medyo maliit sa dami, ngunit napakahalaga mula sa isang praktikal na pananaw. See you soon, good luck sa pag-aaral ng programming language!

Kung kailangan mong i-convert ang isang PHP array sa isang string, mayroong ilang mga tool para dito. Ang paggamit ng isang partikular na tool ay depende sa iyong mga layunin.
1. Implode() function

Sa tulong nito, maaari mong "idikit" ang mga elemento ng array sa isang string, sa pamamagitan ng anumang separator. Magbasa pa: sumabog

Halimbawa:

Echo implode("|", array(1, 2, 3)); // gagawa ng linyang: 1|2|3

Ang function na ito ay may antagonist, explode(), na, sa kabilang banda, hinahati ang string sa delimiter sa array elements. Magbasa pa: sumabog
2. Serialize() function
Ang pangunahing gawain ng function ay ang pagbabago ng isang variable (sa aming kaso, isang array) sa isang estado na angkop para sa imbakan.

$array = array("1" =>; "elem 1", "2"=> "elem 2", "3" => "elem 3"); $string = serialize($array); echo $string; // gagawa ng linyang: a:3:(i:1;s:6:"elem 1";i:2;s:6:"elem 2";i:3;s:7:"elem 3" ;)

Pagkatapos mula sa linyang ito, maaari mong makuha muli ang array:

$array = unserialize($string);

3. json_encode() function

Nagbabalik ng JSON na representasyon ng data. Mababasa mo kung ano ito.
Sa aming kaso, ang function na ito ay kahawig ng serialization, ngunit ang JSON ay pangunahing ginagamit para sa paglipat ng data. Kakailanganin mong gamitin ang format na ito upang makipagpalitan ng data gamit ang javascript sa front end. Higit pang mga detalye: json_encode

$array = array(1 => "isa", 2 => "dalawa",); $json = json_encode($array); echo $json; // ("1":"isa","2":"dalawa")

Ang callback function na json_decode() ay magbabalik ng object na may uri na stdClass kung false ang pangalawang parameter ng function. O magbabalik ito ng associative array kung ang true ay ipinasa bilang pangalawang parameter. Mga detalye dito.

Naka-block ang JavaScript sa iyong browser. Mangyaring paganahin ang JavaScript para gumana ang site!

sumabog

(PHP 3, PHP 4, PHP 5)

sumabog- Pinagsasama-sama ang mga elemento ng array sa isang string (nag-convert ng array sa string)

Paglalarawan

string sumabog(string glue, mga piraso ng array)

Ibinabalik ang string na nakuha sa pamamagitan ng pagsasama-sama ng mga representasyon ng string ng mga elemento ng hanay ng mga piraso, na naglalagay ng string ng pandikit sa pagitan ng mga katabing elemento.

Halimbawa 1: Halimbawa ng paggamit sumabog()

Komento: Para sa makasaysayang mga kadahilanan, mga function sumabog() maaari kang magpasa ng mga argumento sa anumang pagkakasunud-sunod, ngunit para sa pag-iisa sa function sumabog() dapat gamitin ang nakadokumentong pagkakasunud-sunod ng argumento.

Komento: Dahil ang bersyon 4.3.0, ang glue function argument sumabog() ay opsyonal at default sa walang laman na string (""). Para sa backward compatibility, inirerekomenda na palaging ipasa ang parehong argumento.

Komento: Ang function na ito ay ligtas na iproseso ang data sa binary form.

Pinagsasama ng function na ito ang mga halaga ng mga elemento ng array sa isang string. Upang pagsamahin ang mga susi ng mga elemento ng array, gamitin ang sumusunod na code:

php implode para sa mga nested array

Kung magpapasa ka ng multidimensional array para sumabog, makakatanggap ka ng error na "Array to string conversion." Upang maiwasan ang error na ito, gamitin ang sumusunod na katumbas ng implode function:

Function na multi_implode($glue, $array) ($_array=array(); foreach($array as $val) $_array = is_array($val)? multi_implode($glue, $val): $val; return implode($ pandikit, $_array);

Tingnan din ang mga paglalarawan ng function

Ang PHP, bilang isang modernong programming language, ay nagbibigay ng kakayahang magproseso ng data, ang uri nito ay maaaring matukoy sa oras ng paggamit. Maaaring magbago ang uri ng data sa panahon ng pagpapatupad ng programa.

Ang mga string ng character ay ang tanging uri ng data kung saan ang data ng iba pang mga uri ay natural na na-cast, para sa simpleng dahilan na ang anumang ibinigay na data ay palaging isang pagkakasunud-sunod ng mga character.

Mga array sa PHP

Bilang karagdagan sa mga regular na variable, binibigyan ng PHP ang programmer ng syntax at mga function para sa pagtatrabaho sa mga array. Bilang karagdagan sa mga regular na array na nagbibigay ng access sa kanilang mga elemento sa pamamagitan ng key (isang numero mula 0 hanggang sa bilang ng mga elemento), maaari kang gumamit ng mga associative array. Sa huli, ang pag-access ay maaaring isagawa kapwa sa pamamagitan ng isang numeric index (awtomatikong itinalaga) at ng isang key na tinukoy ng programmer.

Nagbibigay ang PHP ng kakayahang magpalit ng mga index at value, na may katuturan dahil ang isang susi ay hindi opisyal na mas mahigpit kaysa sa isang halaga, ngunit dapat itong gamitin nang maingat. Sa mahabang panahon, ang mga tradisyon ng programming ay nakakaakit sa mga titik ng alpabetong Latin. Ang Cyrillic, bilang isang pangkalahatang tuntunin, ay nagdadala ng problema ng mga pag-encode. Hindi mo dapat abusuhin ang mga kakayahan ng wika kapag kailangan mo ng praktikal at ligtas na code.

Ang pinakamainam na opsyon sa index ay isang makabuluhang parirala sa Ingles, mas mabuti na walang mga puwang. Napakaganda na ang PHP syntax ay nagpahayag ng "kalayaan" para sa mga susi, ngunit mas mahusay na magtiwala sa iyong sariling karanasan at tumuon sa ligtas na code.

Ang pinakakawili-wili at praktikal na tampok ng PHP na "arrays to string" na solusyon ay ang posibilidad ng katumbas na conversion ng isa't isa.

PHP: Mga Array at String

Ang PHP function na "arrays to string": $cLine = implode("/ ", $aStyle) ay gumagawa ng character string ng lahat ng elemento ng $aStyle array, na pinaghihiwalay ng "/ " character. Kung tinukoy mo ang " ", pagsasama-samahin ang lahat ng elemento sa isang tuluy-tuloy na pagkakasunud-sunod ng mga character.

Ang inverse function na $aStyle = explode("/", $cLine) ay lumilikha ng array ng lahat ng linya na pinaghihiwalay ng "/" na character.

Kapag ginagamit ang explode() function, ipinapayong, ngunit hindi kinakailangan, na suriin ang pagkakaroon ng nais na karakter ng delimiter sa source string.

Maaari ka ring mag-output ng mga array sa isang string sa PHP gamit ang mas makatao at kontroladong paraan Halimbawa, sa for, while, foreach loop, pagdaragdag ng mga value ng array elements sa isang string variable gamit ang assignment operator: ".=". o ang "." operator, na nagbibigay-daan sa proseso ng pagbuo ng mga nagresultang convert na mga string (proseso ang bawat elemento).

PHP: Mag-print ng array sa string sa pamamagitan ng mga bagay

Ang isang bagay ay isang koleksyon ng data at code. Walang pumipigil sa iyo na maglagay, halimbawa, ng dalawang function sa iyong code: magsulat at magbasa. Salamat sa pamana at polymorphism, kung mayroon kang isang bilog na bagay, maaari kang magkaroon ng mga pagkakaiba-iba nito: asul, pula at berde.

Ang bawat isa ay isusulat (basahin) nang iba, ngunit ang eksaktong paraan ng PHP na "arrays to string" na solusyon ay hindi mahalaga. Sa kanilang core, ang mga bagay ay nagdadala ng isang tiyak na kahulugan, may iba't ibang mga istraktura at iba't ibang mga pamamaraan. Isang halimbawa na may dalawang function - partikular. Kapag gumagawa ng ganoong mekanismo sa PHP, ang mga array ay ilalagay sa isang string nang iba sa bawat partikular na kaso.

Nagbubukas ito ng maraming posibilidad. Ang isang bagay ay may dalawang array, ang isa ay may dalawampu, at ang karaniwang ninuno (karaniwang ang pinakaunang isa ay abstract) ay wala sa lahat. Sa pamamagitan ng paggamit ng kanilang mga karaniwang pamamaraan ng ninuno, hindi mo kailangang mag-alala tungkol sa isang bagay na hindi naisulat, nabasa, naproseso, o ipinapakita.

Salamat sa pamana, kahit anong hugis ang ginagamit saanman sa programa, maaari itong irepresenta bilang isang string at ipasa pabalik sa object ng partikular na hugis na iyon.

Ang pag-convert ng data mula sa isang representasyon patungo sa isa pa ay isang tanyag, kadalasan ang tanging, mekanismo para sa paglutas ng isang problema. Ang array ay isang simpleng kaso ng isang bagay. Ang string ay isang natural na representasyon ng impormasyon para sa paghahatid, pagproseso o pag-iimbak.

Ang karanasan at semantika na ipinatupad sa PHP: ginagawang posible ng mga arrays, function at syntactic structure na lumikha ng pinakamainam na solusyon para sa pagproseso ng impormasyon habang ipinakita ito.

Impormasyon: mga character, string at data

Sa "dalisay" na anyo nito, ang impormasyon ay isang string ng mga character, pagsasalita o isang pagkakasunud-sunod ng mga signal. Lumilitaw ang mga string, array at object sa programming - ito ay mga variant ng artipisyal na mga konstruksyon ng string. Ang mga numero ay mga string din, ngunit mga numero, hindi mga simbolo.

Binibigyang-daan ka ng PHP na i-convert ang isang string sa isang array sa maraming iba't ibang paraan. Mayroong dalawang espesyal na function na gumagawa nito "sa kanilang sarili":

• $aArr = explode("x", "string");
• $aStr = implode("y", $aArr).

Hinahanap ng unang function ang delimiter character na "x" at hinahati ang string na "string" gamit ito. Ang resultang array ay naglalaman ng eksaktong bilang ng mga elemento (linya) na nasa pagitan ng "x" na mga character. Ang simbolo ng separator ay maaaring hindi palaging ang klasiko:

• kuwit;
• tuldok;
• tuldok-kuwit.

Maaari mong hatiin ang isang string sa pamamagitan ng substring o sa pamamagitan ng isang espesyal na kumbinasyon ng mga character.

Ang haba ng string ay strlen() sa PHP, ang haba ng array ay count(). Sa unang kaso, ang bilang ng mga character ay binibilang, sa pangalawang kaso, ang bilang ng mga elemento. Dahil hindi kasama ang delimiter character sa mga elemento ng array, ang halaga ng count() ay magiging katumbas ng bilang ng mga delimiter sa na-convert na string minus one.

Sa reverse transformation ng PHP, ang mga arrays sa string ay kino-convert gamit ang delimiter character (maaaring walang laman), at lahat ng data (mga numero at Boolean expression) ay pinagsama sa isang string. Ang isang elemento ng isang array ay maaaring isa pang array, ngunit ang programmer ay dapat hawakan ang kasong ito partikular. Ang implode() function ay malayo sa recursive.

Sa halimbawang ito, walang problema sa pag-convert ng mga PHP array sa isang string hangga't walang ibang array sa kanilang mga elemento. Kapag na-convert ang mga nauugnay na elemento, mawawala ang pangunahing impormasyon. Sa partikular, ang mga elementong "plum" at "peach" ay aalisin ng kanilang mga susi.

Mga delimiter at susi ng data

Huwag isaalang-alang ang mga tuldok, kuwit, tutuldok, atbp. bilang mga delimiter Ito ay isang espesyal na kaso ng paghihiwalay ng data sa isa't isa. Kapag nag-transform ng string sa PHP, hindi gagana ang isang multidimensional array, at ang mga associative index ay wala nang pinanggalingan.

Ang pag-parse ng string sa pamamagitan ng delimiter ay palaging gumagawa ng mga string. Ngunit hindi ito dahilan para tumigil doon. Ang pagkakaroon ng pag-parse ng isang linya sa mga elemento ng bahagi nito, maaari kang magpatuloy.

Halimbawa, mayroong isang talata na may ilang mga pangungusap (separator "." - tuldok), maraming mga parirala sa pangungusap (mga separator "," - kuwit, ";" - semicolon at "." - tuldok), ang parirala ay naglalaman ng mga salita ( delimiter " " - espasyo, "," - kuwit, ";" - tuldok-kuwit at "."

Sa disassembly na ito sa PHP, ang isang multidimensional array ay madaling makuha, ngunit ang algorithm ay magiging napakapangit: ang bilang ng mga separator ay tataas, at ang kawalan ng koneksyon sa pagitan ng mga katabing talata ay ginagarantiyahan upang matiyak ang pagdoble ng mga pangungusap, parirala at salita.

Sa pamamagitan ng pag-parse ng mga string, maaari mong agad na i-convert ang mga pagkakasunud-sunod ng mga digit sa mga numero, at mga lohikal na halaga sa true at false. Ngunit ito ay sa partikular, ang pangunahing impormasyon ay hindi pa rin lilitaw, dahil ang susi ay ang kahulugan, isang numeric index lamang ang maaaring awtomatikong malikha.

Mga kumplikadong separator

Ang pag-print ng PHP array sa isang string ay kadalasang ginagamit para sa mga layunin ng utility. Ang isang configuration file ay tradisyunal na nakasulat sa linya sa pamamagitan ng linya, na may katumbas na simbolo o isang colon na naghihiwalay sa pangalan mula sa halaga.

Sa solusyon na ito, ang output ng isang array sa PHP ay ginagawa sa isang file, ang string division ay awtomatikong nakuha, at sa reverse recognition, ang mga associative array ay madaling makuha.

Sa pamamagitan ng pagbabasa ng file, nakukuha ng programmer ang mga linya, at sa pamamagitan ng pagsira sa bawat linya ng "=" o ":", nakukuha niya ang pangalan at ang halaga nito. Isang napakasikat na pagmamanipula, bagama't mas moderno ang paggamit ng XML notation para sa simpleng dahilan na bilang karagdagan sa mga pangalan at halaga, ang karagdagang data ay maaaring maimbak at maibalik, halimbawa, mga variable na katangian.

Sa halimbawang may mga talata (halimbawa, natural na teksto para bumuo ng diksyunaryo o ang resulta ng pag-parse para gumawa ng sample ng data), ang mahalaga ay hindi ang partikular na pamamaraan para sa pag-convert ng string sa isang array, ngunit isang komprehensibong solusyon para sa lahat ng mga talata o mga bloke ng impormasyon.

Karaniwan, ang ganitong gawain ay mangangailangan ng reverse solution, kapag ang nabuong "set" ng data ay kailangang gamitin upang maghanap ng impormasyon dito o upang tipunin ito pabalik sa isang string.

Pag-disassembling at muling pagbubuo ng mga string - pagpapatunay ng data

Sa PHP: arrays to string ang eksaktong solusyon. Kung ang pinagmulan ng impormasyon ay maaaring magkaroon ng mga error sa syntax, dagdag na espasyo, o mga maling simbolo, kung gayon ay hindi naroroon ang mga ito sa panahon ng pag-parse. Ang resulta ng pagbabago ng paunang impormasyon ayon sa hindi nakasulat na mga batas ng programming ay isinasagawa nang mahigpit na pormal, at ang resulta ay malinaw na ilalatag sa mga istante.

Ang reverse procedure ay gagawa ng tamang source string. Kung ihahambing mo ang dami ng pinagmulang impormasyon at ang resulta ng reverse transformation, maaari kang gumawa ng mga konklusyon tungkol sa kung saan nagkaroon ng mga error o pagkawala ng data. Sa PHP, ang haba ng isang array sa konteksto ng orihinal na haba ng string ay maaaring magbigay-daan sa amin na gumuhit ng mga kinakailangang konklusyon.

Mga tag ng oras, petsa at kaganapan

Sa pagbuo ng mga kritikal na proyekto, kapag lumilikha ng mga control object, halimbawa, oras o mga kaganapan, ang isang hilera ay isang representasyon ng data, at ang isang array ay isa pa. Ngunit sa aplikasyon sila ay katumbas.

Kapag kinakailangan upang magsagawa ng mga kalkulasyon sa matematika o lohikal, ang programmer ay manipulahin ang array kapag kinakailangan upang mag-imbak ng data, ginagamit niya ang string na bersyon.

I-access ang mga index sa mga patlang ng database - isang tunay na kasanayan ng magkasanib na pagkilos ng MySQL at PHP, mga arrays sa isang hilera = isang index sa mga hilera ng ilang mga talahanayan ng database. Kung ang database ay naglalaman ng isang dosenang mga talahanayan, at sa bawat talahanayan ang mga hilera ay maaaring mapili sa pamamagitan ng isang kumbinasyon ng mga pangalan (mga halaga) sa isang tiyak na kumbinasyon, pagkatapos ay lumikha ng mga row access arrays, maaari kang magkaroon ng access sa kanila sa dakong huli gamit ang isang index formation algorithm, at hindi sa pamamagitan ng paghahanap sa database.

Ang pag-convert ng array sa isang string ay maaaring ituring bilang isang algorithm para sa pagbuo ng nais na index, habang ang mga nilalaman ng array ay nabuo sa ilalim ng kontrol ng ganap na magkakaibang mga kaganapan o mga aksyon ng user.

Pinagsasama-sama ang mga Array

Hinahayaan ka ng mga function ng PHP na malayang manipulahin ang mga array. Ngunit laging lumalabas ang mga problema sa pagpili ng natatanging data o paghahanap ng data sa isang array.

Ang unang problema ay nalutas nang paulit-ulit: ang isang array (o ilang mga array) ay inuulit at isang string ng mga natatanging halaga ay nabuo - isang malinaw na solusyon, ngunit hindi ang pinaka-epektibo.

Ang paghahanap ng data sa isang array ay isa ring cycle, at kung maraming elemento, ang cycle ay magiging medyo mahaba at aabutin ng kapansin-pansing tagal ng oras. Posibleng magpadala ng array sa isang string at gamitin ang strpos() function upang mahanap ang paglitaw ng nais na elemento, ngunit ito ay magpapakilala sa problema ng pag-detect ng maling pangyayari.

Halimbawa, ang salitang "tray" ay hinanap, at ang paglitaw nito ay natagpuan sa salitang "martilyo". Maaari mong mapupuksa ang mga naturang error kung ang lahat ng mga elemento ng array ay pinagsama sa isang string gamit ang isang espesyal na delimiter, na maiiwasan ang kawalan ng katiyakan.

Kung ang linya ay naglalaman ng "[tray]" at "[martilyo]", walang magiging problema sa paghahanap.

Ngunit walang garantiya na, sa totoong dami ng data, ang strpos() function ay gagana nang mas mabilis kaysa sa isang loop na umuulit sa mga elemento ng array.

Ang pinakamahusay na solusyon ay para sa array o string na gawin ang tamang bagay sa sarili nitong. Kung medyo kumplikado namin ang mga array at pasimplehin ang mga string, dahil ang una ay isang espesyal na kaso ng isang bagay, at ang huli ay tradisyonal na serialization, kung gayon lahat ay gagawa ng kanilang sariling bagay.

Sa tamang oras, ang bagay ay isang array, at kapag kailangan ang isang string, ito ay magiging isang string. Sa kasong ito, ganap na hindi kinakailangan na magkaroon ng parehong array at isang string sa bagay sa parehong oras. Maaari kang bumuo ng isang natatanging istraktura ng data na may mabilis na pag-access. At ilagay ang "array" at "string" logic sa object method.

Pinapasimple ng object-oriented na diskarte ang solusyon ng maraming problema sa pagpoproseso ng impormasyon ng string, pinapayagan ka nitong huwag tumuon sa mga arrays, loops, at mismong string processing function ng PHP.

Ang parehong mga string at array ay ang tunay na kahulugan ng katotohanan, aplikasyon, gawain. Walang ganoong gawain - pagpapadala ng mga array sa mga string sa PHP. Ngunit mayroong isang gawain upang makakuha ng isang talata (pangungusap, parirala, salita, numero...) batay sa mga resulta na nakuha sa nakaraang algorithm.

Ang nakaraang algorithm ay nagdadala ng isang kahulugan, at ang eksaktong pagpapahayag ng kahulugan na ito ay nakapaloob sa array. Ang susunod na yugto ng algorithm ay ang pagbabago ng kahulugan sa isa pang representasyon, na maginhawa para sa karagdagang pagproseso o aplikasyon.

Sa pamamagitan ng pagtingin sa algorithm bilang dynamics ng kahulugan at pagbabago ng data, posible na bumuo ng maaasahan, naiintindihan at epektibong mga pagbabago.