Set theory. Alam ko kung gaano karaming mga tao ang natatakot sa mga mathematician, ngunit ang partikular na set theory (naive) ay napaka-simple at naiintindihan. Bukod dito, palagi nating ginagamit ang mga elemento nito sa pang-araw-araw na buhay. At sa programming ito ay nangyayari sa bawat hakbang.

Ang pangunahing konsepto ng set theory, nakakagulat, ay isang grupo ng. Ang isang set ay nagsasaad ng isang koleksyon ng mga bagay na may di-makatwirang kalikasan, na itinuturing bilang isang solong kabuuan. Ang pinakasimpleng halimbawa ay mga numero. Ang set ng Arabic numeral ay may kasamang 10 elemento at ay pangwakas. Ang konsepto ng finiteness ay intuitive at nangangahulugan na ang isang set ay may hangganan na bilang ng mga elemento.

Ang isang halimbawa ng isang infinite set ay natural na mga numero. Sa turn, ang hanay ng mga natural na numero ay isang subset ng mga integer, na kung saan ay isang subset ng mga rational na numero, at iba pa.

Ang ibig sabihin ng "Subset" ay ang lahat ng elemento ng isang set ay kasama rin sa isa pang set, na tinatawag superset(kamag-anak sa isang subset).

Ang kumakatawan sa mga hanay sa pamamagitan ng mga bilog ay medyo maginhawa. Mabilis mong maa-assess kung paano nauugnay ang iba't ibang set sa isa't isa.

Ngunit ang mga bagay sa matematika tulad ng mga numero ay hindi lamang ang posibleng mga bagay ng mga set. Ang isang set ay maaaring tawaging grupo ng mga taong nakatayo sa hintuan ng bus na naghihintay ng kanilang bus, o mga residente ng mga apartment sa isang bahay, lungsod o bansa. Anumang koleksyon ng anumang mga bagay na gusto naming isaalang-alang bilang isang solong kabuuan.

Ang pangunahing bagay para sa amin sa set theory ay ang mga operasyon sa kanila. Kabilang dito ang: karagdagan, unyon, intersection, pagkakaiba, produkto ng Cartesian at ilang iba pa.

Isang simpleng halimbawa. Kapag binisita mo ang pahina ng ibang tao sa Facebook, ipinapakita sa iyo ng Facebook ang isang bloke sa mga magkakaibigan. Kung ipagpalagay namin na ang iyong mga kaibigan at mga kaibigan ng iyong kaibigan ay dalawang set, kung gayon ang magkakaibigan ay ang hanay na nakuha bilang intersection ng mga orihinal na hanay ng mga kaibigan.

Sa paglipat sa programming, mapapansin mo na ang isang array ay halos kapareho sa isang set, at maaari nga itong isipin na ganoon. Bakit ito napakahalaga? Sa pamamagitan ng pag-unawa sa mga prinsipyo sa likod ng ilang partikular na operasyon, maaari mong ipatupad ang mga ito sa pinakamabilis at pinakamabisang paraan. Halimbawa, sa pag-alam na kailangan mo ng isang set ng intersection operation sa php, maaari mong subukang maghanap ng isang function na gumagawa ng gawain. Upang gawin ito, ipasok lamang ang query sa Google: Magsalubong ang set ng php(set - set, intersect - intersection). Ang una (kahit para sa akin) na link sa mga resulta ng paghahanap ay humahantong sa nais na array_intersect function. Ang parehong bagay ay naghihintay sa iyo sa iba pang mga operasyon. Ito ay isang bahagyang sagot sa tanong na "kailangan ba ng mga programmer ng matematika?"

Sa pamamagitan ng paraan, hindi lahat ng mga wika ay may mga built-in na function para sa pagtatrabaho sa mga set. Sa ilan, kailangan mong mag-install ng mga karagdagang aklatan para dito, at sa ilan, halimbawa, sa Ruby, ang mga pagpapatakbo na may mga hanay ay ipinapatupad gamit ang mga operator ng aritmetika (unyon ng mga hanay: coll1 + coll2).

Hiwalay, ito ay nagkakahalaga ng pagsasabi na ang mga relational database ay binuo sa mga ideya ng relational algebra, kung saan ang set theory ay gumaganap ng isang sentral na papel. Ang mga database ay isang mahalagang bahagi ng web development, at malalaman natin ang mga ito sa ibang pagkakataon.

Tingnan natin ang mga pangunahing operasyon:

Interseksyon

Ang intersection ng mga set ay isang set na kinabibilangan ng mga elemento na lumilitaw sa lahat ng ibinigay na set sa parehong oras.

["vasya", "petya"]

Ang function na ito ay tumatanggap ng anumang bilang ng mga array. Iyon ay, mahahanap mo ang intersection ng anumang bilang ng mga array sa isang tawag.

Isang asosasyon

Ang unyon ng mga set ay isang set na naglalaman ng mga elemento ng lahat ng ibinigay na set. Itakda ang unyon sa PHP ay hindi maaaring gawin sa isang tawag, ngunit maaari itong gayahin sa pamamagitan ng pagkonekta ng dalawang function:

["vasya", "kolya", "petya", "igor", "petya", "sergey", "vasya", "sasha"]; // ang unique ay nag-aalis ng mga duplicate $sharedFriends = array_unique($friends); // => ["vasya", "kolya", "petya", "igor", "sergey", "sasha"]

Pagdaragdag (pagkakaiba)

Ang pagkakaiba ng dalawang set ay isang set na kinabibilangan ng mga elemento ng unang set na hindi kasama sa pangalawa. Sa programming, madalas na tinatawag ang operasyong ito diff.

["kolya"]

Nabibilang sa karamihan

Maaari mong suriin kung ang isang elemento ay kabilang sa isang set gamit ang in_array function:

Gawain
Mayroong dalawang array, at gusto mong hanapin ang kanilang unyon (lahat ng elemento, ngunit kung ang isang elemento ay nasa parehong array, ito ay binibilang nang isang beses), intersection (mga elemento sa parehong array), o pagkakaiba (mga elemento sa isang array na wala sa Yung isa).

Solusyon
Upang tukuyin ang isang unyon:
$union = array_unique(array_merge($a, $b));

Upang kalkulahin ang intersection:
$intersection = array_intersection($a, $b);

Upang makahanap ng isang simpleng pagkakaiba:
$difference = array_diff($a, $b);

At para makuha ang simetriko pagkakaiba (eksklusibo O):

Pagtalakay
Marami sa mga sangkap na kinakailangan para sa naturang mga kalkulasyon ay binuo sa PHP; kailangan mo lamang na pagsamahin ang mga ito sa naaangkop na pagkakasunud-sunod.

Kapag ang isang unyon ay nakuha mula sa dalawang array, ang isang higanteng array ay nilikha kasama ang lahat ng mga halaga ng orihinal na array. Ngunit ang array_merge() function ay nagbibigay-daan sa mga duplicate na value kapag pinagsasama ang dalawang numeric arrays, kaya kailangan mong tawagan ang array_unique() function.
upang i-filter ang mga naturang elemento.

Gayunpaman, ito ay maaaring magresulta sa mga gaps dahil ang array_unique() function ay hindi compact ang array. Gayunpaman, hindi ito isang problema dahil pareho ang foreach na pahayag at ang bawat() function na humahawak sa mga arrays na kakaunti ang populasyon nang walang interference.

Ang function para sa pagkalkula ng intersection ay pinangalanang array_intersection() at hindi nangangailangan ng anumang karagdagang pagsisikap.

Ang array_diff() function ay nagbabalik ng array na naglalaman ng lahat ng natatanging elemento ng $old array na wala sa $new array. Ito ay tinatawag na isang simpleng pagkakaiba:


$difference = array_diff($old, $new);
Array
=> hindi
=> sa
)

Ang nagreresultang $difference array ay naglalaman ng "not" at "to" dahil ang array_diff() ay case sensitive. Hindi kasama dito ang "whatever" element dahil wala ito sa $old array.

Upang makuha ang kabaligtaran na pagkakaiba, o, sa madaling salita, upang mahanap ang mga natatanging elemento ng $new array na nawawala sa $old array, kailangan mong palitan ang mga argumento:
$old = array("To", "be", "or", "not", "to", "be");
$new = array("To", "be", "or", "whatever");
$reverse_diff = array_diff($bago, $luma);
Array
=> kahit ano
)

Ang $reverse_diff array ay naglalaman lamang ng "whatever" na elemento.

Kung kailangan mong maglapat ng function o iba pang filter sa array_diff() function, i-embed ang sarili mong pagkakaiba (subtraction) algorithm:

// ilapat ang isang case-insensitive subtraction algorithm; pagkakaiba -i
$nakita = array();
foreach ($new as $n) (
$nakita++;
}
foreach ($old as $o) (
$o = strtolower($o);
kung (!$nakita[$o]) ($diff[$o] = $o; )
}

Ang unang foreach statement ay lumilikha ng isang associative array para sa karagdagang paghahanap.

Pagkatapos ay nag-loop ito sa $old array at, kung ang elemento ay hindi matagpuan sa paghahanap, ito ay idinaragdag sa $diff array.

Ang prosesong ito ay maaaring mapabilis sa pamamagitan ng pagsasama-sama ng array_diff() at array_map() function:

$diff = array_diff(array_map("strtolower", $old),
array_map("strtolower", $new));

Ang simetriko na pagkakaiba ay kung ano ang nasa $a ngunit hindi sa $b, kasama ang nasa $b ngunit wala sa $a:

$difference = array_merge(array_diff($a, $b), array_diff($b, $a));

Kapag naitatag, ang algorithm ay sumusulong. Ang array_diff() function ay tinatawag na dalawang beses at tinutukoy ang dalawang pagkakaiba. Pagkatapos ay pinagsama sila sa isang array. Hindi na kailangang tumawag sa array_unique() dahil ang mga array na ito ay partikular na idinisenyo upang walang mga karaniwang elemento.

Binibigyang-daan ka ng mga function na ito na manipulahin ang mga array sa iba't ibang paraan. Ang mga array ay mainam para sa pag-iimbak, pagbabago, at pagtatrabaho sa mga hanay ng mga variable.

Sinusuportahan ang mga single- at multi-dimensional array, parehong nilikha ng user at ibinalik bilang resulta ng ilang function. May mga espesyal na function para sa pagtatrabaho sa mga database na nagpapadali sa pagtratrabaho sa mga arrays ng data na ibinalik bilang resulta ng pagsasagawa ng mga query; Mayroon ding mga function na nagbabalik ng mga array bilang mga resulta.

Upang matuto nang higit pa tungkol sa kung paano nilikha at ginagamit ang mga array sa PHP, tingnan ang kabanata ng Mga Array ng tutorial na ito.

Pag-install

Walang kinakailangang pag-install para magamit ang mga feature na ito dahil bahagi sila ng PHP core.

Mga Paunang Natukoy na Constant

Ang mga constant na nakalista sa ibaba ay palaging magagamit bilang bahagi ng PHP core.

CASE_LOWER(integer)

CASE_LOWER ginamit na may function array_change_key_case() upang ipahiwatig kung ang mga array key ay dapat i-convert sa mga maliliit na character. Default na function array_change_key_case() Ginagamit ang pare-parehong ito.

CASE_UPPER(integer)

CASE_UPPER ginamit na may function array_change_key_case() upang isaad kung ang mga array key ay dapat na i-convert sa malalaking character.

array_change_key_case -- Ibalik ang isang array na ang mga character key ay na-convert sa upper o lower case na mga character array_chunk -- Hatiin ang isang array sa mga chunks array_combine -- Lumikha ng isang bagong array gamit ang isang array bilang mga key at isa pa bilang mga katumbas na halaga array_count_values ​​​​- - Bilangin ang bilang ng lahat ng mga value array_diff_assoc -- Kalkulahin ang array divergence na may karagdagang index checking array_diff_key -- Compute array divergence sa pamamagitan ng paghahambing ng mga key array_diff_uassoc -- Compute array divergence na may karagdagang index checking na isinagawa gamit ang user-defined array function array_diff_ukey -- Compute gamit ang array_diff_ukey -- Compute key comparison callback array_diff -- Kalkulahin ang array divergence array_fill -- Punan ang isang array na may partikular na value array_filter -- Maglapat ng filter sa isang array gamit ang array_flip callback -- Magpalit ng array values ​​​​array_intersect_assoc -- Compute array convergence na may karagdagang index check array_intersect_key -- Kalkulahin ang array intersection sa pamamagitan ng paghahambing ng mga key array_intersect_uassoc -- Kalkulahin ang array intersection na may karagdagang index check na ginawa gamit ang user-defined function array_intersect_ukey -- Kalkulahin ang array intersection gamit ang key comparison callback array_intersect -- Kalkulahin ang array convergence array_key_exists -- Suriin kung ang tinukoy na key ay nasa array array_keys -- Piliin ang lahat ng key sa array array_map -- Maglapat ng callback function sa lahat ng elemento ng tinukoy na array array_merge_recursive -- Paulit-ulit na pagsamahin ang dalawa o higit pang array array_merge -- Pagsamahin ang dalawa o higit pang array array_multisort -- Pagbukud-bukurin ang maramihang arrays o multidimensional arrays array_pad -- Palakihin ang laki ng array sa isang ibinigay na value array_pop -- Kunin ang huling elemento ng array array_product -- Kalkulahin ang produkto ng array values ​​array_push -- Magdagdag ng isa o higit pang elemento sa dulo ng isang array array_rand -- Pumili ng isa o higit pang random values ​​​​mula sa array_reduce -- Paulit-ulit na bawasan ang isang array sa iisang value gamit ang callback function array_reverse -- Nagbabalik ng array na may mga elemento sa reverse order array_search -- Hinahanap ang array para sa isang ibinigay na value at ibabalik ang kaukulang key kung matagumpay na array_shift -- Kunin ang unang elemento ng array array_slice - - Pumili ng slice ng array array_splice -- Alisin ang isang sequence ng array elements at palitan ito ng isa pang sequence array_sum -- Kalkulahin ang kabuuan ng array values ​​array_udiff_assoc -- Kalkulahin ang divergence sa mga array na may karagdagang index checking, gamit ang callback function array_udiff_uassoc upang ihambing ang mga halaga -- Compute divergence sa mga array na may karagdagang index checking, gamit ang array_udiff callback function upang ihambing ang mga halaga at indeks -- Kalkulahin array divergence gamit ang array_uintersect_assoc callback function para sa paghahambing -- Kalkulahin ang array intersection na may karagdagang index checking, gamit ang array_uintersect_uassoc callback function upang ihambing ang mga value -- Kalkulahin ang array intersection na may karagdagang index checking gamit ang array_uintersect callback upang ihambing ang mga indeks at halaga - - Kalkulahin ang intersection ng mga array gamit ang array_unique callback upang ihambing ang mga value -- Alisin ang mga duplicate na value mula sa array array_unshift -- Magdagdag ng isa o higit pang elemento sa simula ng array array_values ​​​​-- Piliin ang lahat ng value ng isang array array_walk_recursive -- Paulit-ulit na maglapat ng custom na function sa bawat elemento ng array array_walk -- Maglapat ng custom na function sa bawat elemento ng array array -- Lumikha ng array arsort -- Pagbukud-bukurin ang array sa reverse order, pinapanatili ang mga key sort - - Pagbukud-bukurin ang array, pinapanatili ang mga key na compact -- Lumikha ng array na naglalaman ng mga variable na pangalan at ang kanilang mga halaga