Tutulungan ka ng araling ito na maunawaan ang dalawang mahalagang uri ng mga uri ng data sa computer programming: primitive at non-primitive na uri ng data. Ang mga uri ng data ay tulad ng iba't ibang mga kahon. Ang ilan ay maliit at simple, at ang ilan ay mas malaki at ginawa sa pamamagitan ng pagsasama-sama ng maliliit na kahon. Kahit na nag-aaral kami ng mga ideya sa computer, maaari mong isipin ang mga ito tulad ng mga bagay na ginagamit mo araw-araw. Ipinapaliwanag ng araling ito kung ano ang mga ito, kung paano sila nagkakaiba, at nagpapakita ng mga madaling halimbawa na maiuugnay mo.
Sa mga computer, ang isang uri ng data ay nagsasabi sa computer kung anong uri ng impormasyon ang nakaimbak. Sinasabi nito sa computer kung ang impormasyon ay isang numero, isang titik, o kahit na iba pa. Isipin na mayroon kang iba't ibang mga kahon sa bahay. Ang isang kahon ay maaaring maglaman ng mga lapis, ang isa ay maaaring maglaman ng mga laruan, at ang isa ay maaaring maglaman ng mga krayola. Ang bawat kahon ay ginawa upang hawakan ang isang uri ng bagay. Sa parehong paraan, pinapanatili ng mga uri ng data ang magkatulad na uri ng impormasyon nang magkasama.
Ang mga uri ng data ay tumutulong sa computer na malaman kung paano gamitin ang impormasyon. Sinasabi nila sa computer kung gaano karaming espasyo ang kailangan para mag-imbak ng data. Tinutulungan din nila ang computer na maunawaan kung ano ang gagawin kung kailangan mong magdagdag ng mga numero nang magkasama o ayusin ang mga titik. Napakahalaga nito para sa paggawa ng mga programang gumagana nang maayos at ligtas.
Ang mga primitive na uri ng data ay ang pinakasimpleng uri ng mga uri ng data. Ang mga ito ay binuo sa wika ng computer. Hindi sila maaaring hatiin sa mas maliliit na bahagi. Isipin ang mga ito bilang mga bloke ng pagbuo ng data. Ang bawat primitive na uri ng data ay nagtataglay ng isang solong halaga.
Integer: Ang integer ay isang buong numero. Wala itong decimal point. Halimbawa, kapag binibilang mo ang bilang ng mga mansanas sa iyong lunchbox, iyon ay isang integer. Kung mayroon kang 4 na mansanas, ang numero 4 ay isang integer.
Halimbawa: Isipin mong sasabihin mo, "Mayroon akong 4 na laruan." Dito, ang 4 ay isang buong numero, kaya ito ay isang integer.
Floating Point (Float): Ang float ay isang numero na may decimal point. Maaari itong kumatawan ng mga buong numero at bahagi ng mga numero. Halimbawa, kung magsusukat ka ng isang piraso ng string at ito ay 3.5 pulgada ang haba, ang bilang na 3.5 ay isang float.
Halimbawa: Kung may narinig kang nagsasabing, "Ang bote ay may 1.25 litro ng tubig," ang bilang na 1.25 ay isang float dahil mayroon itong decimal.
Tauhan: Ang karakter ay isang titik, numero, o simbolo. May hawak itong isang maliit na piraso ng teksto. Halimbawa, ang letrang A o ang numero 7 kapag ito ay isang digit lamang ay mga character.
Halimbawa: Isipin na mayroon kang sticker na may letrang B. Ang sticker na iyon ay nagpapakita ng isang karakter.
Boolean: Ang isang boolean ay nagtataglay ng isang simpleng halaga ng katotohanan. Maaari itong maging totoo o mali . Ito ay tulad ng pagsagot ng oo o hindi na tanong. Halimbawa, "Umuulan ba sa labas?" maaaring tama o mali ang sagot.
Halimbawa: Kapag nagpasya ka kung gusto mong maglaro sa labas, maaari mong sabihin ang "Oo" (totoo) o "Hindi" (mali). Sa isang computer, ito ay pinangangasiwaan ng mga boolean.
Napakahalaga ng mga primitive na uri ng data dahil sila ang mga pangunahing sangkap para sa pagbuo ng mas kumplikadong data. Palagi silang handang gamitin at gumana nang napakabilis sa isang computer.
Ang mga hindi primitive na uri ng data ay hindi binuo sa wika. Ginagawa ang mga ito sa pamamagitan ng pagsasama-sama ng mga primitive na uri ng data. Isipin ang mga ito bilang isang koleksyon o kahon na naglalaman ng maraming maliliit na kahon. Tinutulungan nila kaming pagsama-samahin ang maraming halaga.
Ang isang karaniwang hindi primitive na uri ng data ay isang array . Ang array ay tulad ng isang hilera ng mga locker kung saan ang bawat locker ay may halaga. Halimbawa, kung mayroon kang listahan ng iyong limang paboritong kulay, maaari mong iimbak ang lahat sa isang array.
Halimbawa: Isipin na mayroon kang isang kahon na naglalaman ng pulang bola, asul na bola, at berdeng bola. Ang kahon ay parang array dahil pinagsasama-sama nito ang ilang bola (values).
Ang isa pang halimbawa ng isang hindi primitive na uri ng data ay isang listahan . Ang isang listahan ay katulad ng isang array. Pinapanatili nito ang maraming value sa isang lugar at maaari kang magdagdag o mag-alis ng mga item mula sa isang listahan. Isipin ito tulad ng iyong school bag kung saan mayroon kang isang pencil case, isang libro, at isang lunchbox na lahat ay pinagsama-sama.
Halimbawa: Isaalang-alang ang isang listahan ng mga prutas na may kasamang "mansanas", "saging", at "cherry". Pinapangkat ng listahang ito ang mga pangalan ng prutas sa isang koleksyon para sa madaling pag-access.
Ang isang string ay itinuturing din bilang isang hindi primitive na uri ng data sa maraming mga programming language. Ang string ay isang set ng mga character na pinagsama-sama. Kahit na ang isang titik ay isang karakter (isang primitive na uri), ang isang buong salita o pangungusap ay isang string dahil ito ay isang pangkat ng mga character.
Halimbawa: Ang salitang "Hello" ay isang string. Binubuo ito ng mga karakter na H, e, l, l, at o.
Maaaring kabilang sa iba pang hindi primitive na uri ng data ang mga bagay, talaan, at koleksyon. Ang mga ito ay binuo ng mga programmer upang malutas ang mas malalaking problema. Tumutulong sila na ayusin ang data sa paraang may katuturan para sa programa.
Ngayon na nakita natin kung ano ang bawat uri, maaari nating tingnan kung paano sila naiiba sa bawat isa. Narito ang ilang simpleng paraan upang maunawaan ang mga pagkakaiba:
Mag-isip ng mga primitive na uri tulad ng mga solong krayola sa isang kahon. Ang bawat krayola ay isang kulay. Ang mga hindi primitive na uri, sa kabilang banda, ay parang drawing set na naglalaman ng maraming krayola, papel, at marker. Parehong kapaki-pakinabang, ngunit nagsisilbi sila ng iba't ibang layunin.
Tingnan natin kung paano gumagana ang mga ideyang ito sa mga simpleng halimbawa. Titingnan natin ang tatlong halimbawa na nagpapakita kung paano magagamit ang mga primitive at non-primitive na uri ng data sa pang-araw-araw na mga ideya sa programming.
Halimbawa 1: Paggamit ng Integer (Primitive Data Type)
Isipin na gusto mong itago ang iyong edad sa isang computer program. Ang edad ay isang buong numero, kaya maaari kang gumamit ng isang integer. Sa maraming programming language, maaari mong isulat ang:
int edad = 10;
Sinasabi nito sa computer na iimbak ang numerong 10 sa variable na tinatawag na edad . Alam ng computer na ang edad ay isang simpleng numero. Ito ay isang magandang halimbawa ng isang primitive na uri ng data.
Hakbang-hakbang na Paliwanag:
Hakbang 1: Lumilikha kami ng variable na tinatawag na edad .
Hakbang 2: Itinalaga namin ang numero 10 dito.
Hakbang 3: Alam na ngayon ng computer na ang edad ay isang numero na walang anumang bahagi o titik. Ginagamit nito ang integer na ito upang gumawa ng mga kalkulasyon kung kinakailangan.
Halimbawa 2: Paggamit ng Boolean (Primitive Data Type)
Isipin na nagpapasya ka kung gusto mong magkaroon ng oras ng meryenda ngayon. Ang sagot ay maaari lamang oo o hindi. Sa wika ng computer, gumagamit kami ng boolean upang iimbak ang pagpipiliang ito. Maaari kang makakita ng tulad ng:
bool snackTime = totoo;
Sinasabi nito sa computer na ang sagot sa "Mayroon ba akong oras ng meryenda?" ay totoo (o oo). Ito ay isang napakasimpleng uri ng data na nagtataglay ng isa sa dalawang halaga: totoo o mali.
Hakbang-hakbang na Paliwanag:
Hakbang 1: Lumilikha kami ng variable na tinatawag na snackTime .
Hakbang 2: Itinatalaga namin ang halagang totoo dito.
Hakbang 3: Alam na ngayon ng computer na naka-on o tama ang opsyon sa oras ng meryenda.
Halimbawa 3: Paggamit ng Array (Non-Primitive Data Type)
Ipagpalagay na gusto mong matandaan ang iyong nangungunang tatlong paboritong kulay. Sa halip na lumikha ng tatlong magkakahiwalay na variable, maaari mong iimbak ang mga ito sa isang array. Hinahayaan ka ng array na panatilihing magkasama ang ilang item. Sa ilang programming language, maaari kang sumulat ng:
Kulay ng string[] = {"Red", "Blue", "Green"};
Dito, ang mga kulay ng array ay mayroong tatlong halaga. Ang bawat isa sa mga halagang ito ay isang string (isang pangkat ng mga character). Ang array na ito ay isang hindi primitive na uri ng data dahil pinagsama-sama nito ang ilang primitive na value (ang mga character na bumubuo sa bawat pangalan ng kulay).
Hakbang-hakbang na Paliwanag:
Hakbang 1: Nagdedeklara kami ng array na tinatawag na mga kulay na magtataglay ng mga string.
Hakbang 2: Naglagay kami ng tatlong pangalan ng kulay sa loob ng array: "Red", "Blue", at "Green".
Hakbang 3: Ngayon ay magagamit na ng computer ang hanay ng mga kulay upang matandaan ang lahat ng mga paboritong kulay bilang isang piraso ng impormasyon kahit na ang mga ito ay binubuo ng maraming mga character.
Gumagamit ang mga computer ng mga uri ng data upang pangasiwaan ang impormasyon sa isang napakaorganisadong paraan. Kapag nagbigay ka ng numero sa isang computer, alam nito kung paano ito idadagdag o i-multiply. Kapag binigyan mo ang isang computer ng isang string, alam nito na ito ay isang piraso ng teksto, tulad ng iyong pangalan.
Kailangang malaman ng computer ang pagkakaiba sa pagitan ng isang numero at isang pangkat ng mga numero. Halimbawa, kung hihilingin mo sa computer na magdagdag ng 2 at 3 , magko-compute ito:
\(\textrm{2 + 3 = 5}\)
Ang simpleng operasyong ito ay gumagamit ng mga primitive na uri ng data. Ang computer ay gumagana nang napakabilis sa mga simpleng bloke ng data na ito. Sa kabilang banda, kapag ang computer ay gumagamit ng isang hindi primitive na uri ng data tulad ng isang array, maaaring kailanganin nitong tumingin sa maraming numero o titik upang magawa ang trabaho nito. Halimbawa, kung mayroon kang array na naglalaman ng edad ng lahat ng iyong mga kaklase, maaaring dumaan ang computer sa listahan upang mahanap ang pinakabata o pinakamatandang edad.
Ang pag-unawa sa tamang uri ng data na gagamitin ay napakahalaga sa programming. Kung paghaluin mo ang mga uri, maaaring malito ang computer. Ito ay katulad ng pagsubok na magkasya sa isang parisukat na bloke sa isang bilog na butas. Kapag ginamit mo ang tamang uri ng data, gumagana ang lahat ng mas mahusay at mas mabilis.
Gumamit tayo ng ilang simpleng halimbawa sa totoong buhay upang ihambing ang mga primitive at hindi primitive na uri ng data.
Primitive (Mga Simpleng Item):
Isipin na mayroon kang isang solong laruang kotse. Ang kotse na ito ay simple. Ito ay isang bagay at alam mo kung ano ito. Sa mundo ng mga uri ng data, ang laruang sasakyan na ito ay parang integer o boolean. Ito ay isang piraso at gumagawa ng isang bagay lamang.
Non-Primitive (Mga Koleksyon ng Mga Item):
Ngayon, isipin na mayroon kang isang buong kahon ng laruan na puno ng maraming iba't ibang mga kotse. Ang iba ay pula, ang iba ay asul, at ang iba ay berde. Ang laruang kahon na ito ay parang array o listahan. Ang kahon ay naglalaman ng maraming maliliit na laruang kotse. Kahit na ang bawat kotse ay simple, ang pagsasama-sama ng mga ito ay nagbibigay sa iyo ng higit pang mga pagpipilian. Madali mong mahahanap ang kotseng gusto mo o maglaro sa lahat ng sasakyan.
Ipinapakita ng mga halimbawang ito na minsan kailangan mo lang ng isang simpleng piraso ng data, at sa ibang pagkakataon kailangan mo ng koleksyon ng mga katulad na piraso. Ang parehong mga uri ay lubhang nakakatulong. Ang mga primitive na uri ng data ay ang mabilis at madaling bahagi. Ang mga hindi primitive na uri ng data ay ang mga pangkat na tumutulong sa pag-aayos at pamamahala ng higit pang impormasyon.
Ang paggamit ng iba't ibang uri ng data ay nakakatulong na gawing mas malinaw at mas madaling buuin ang mga program. Kapag nagpasya ka sa isang uri ng data, sasabihin mo sa computer nang eksakto kung paano pangasiwaan ang iyong impormasyon. Pinipigilan nito ang mga error at tinitiyak na ginagamit ng computer ang tamang dami ng memorya.
Halimbawa, kung gusto mong gumawa ng matematika gamit ang mga numero, gumamit ka ng mga primitive na uri tulad ng mga integer o float. Ngunit kung gusto mong magpakita ng pangungusap sa screen, gumamit ka ng string. Kung gusto mong matandaan ang isang listahan ng mga pangalan, gumamit ka ng array o listahan. Tinutulungan nito ang computer na malaman kung ano ang aasahan.
Ang pagpili ng tamang uri ng data ay tulad ng pagpili ng tamang tool kapag gumagawa ka ng isang bagay. Kung ikaw ay nagtatayo ng isang maliit na birdhouse, isang simpleng martilyo ang magagawa. Ngunit kung ikaw ay nagtatayo ng isang malaking bahay, maaaring kailangan mo ng maraming iba't ibang mga tool. Sa programming, ang mga primitive na uri ng data ay parang mga simpleng tool, at ang mga hindi primitive na uri ng data ay parang toolbox na may maraming iba't ibang tool.
Kahit na ang mga ideyang ito ay nagmula sa mga programa sa kompyuter, ang mga konsepto ay kumokonekta sa pang-araw-araw na buhay. Kapag inayos mo ang iyong mga laruan, maaari mong ilagay ang mga katulad na laruan sa isang kahon. Kapag sumulat ka ng isang kuwento, gumagamit ka ng mga titik at salita na pinagsama-sama upang bumuo ng mga pangungusap. Ang bawat titik ay makikita bilang isang primitive na elemento, habang ang pangungusap ay isang hindi primitive na pagpapangkat ng maraming mga titik.
Sa isang silid-aralan, maaaring hilingin sa iyo ng iyong guro na pumila ayon sa taas. Ang taas ng bawat estudyante ay parang primitive na numero. Ngunit kapag inayos ng guro ang mga mag-aaral sa pagkakasunud-sunod, naglalagay siya ng isang listahan, na isang hindi primitive na uri ng data. Tinutulungan siya ng listahan na makita kung sino ang pinakamatangkad at kung sino ang pinakamaikli.
Sa maraming laro sa computer, sinusubaybayan ng laro ang marka ng isang manlalaro (isang integer), pangalan ng manlalaro (isang string), at ang status ng laro (isang boolean na nagpapakita kung tapos na ang laro). Ito ang lahat ng mga halimbawa ng paggamit ng mga tamang uri ng data para sa tamang trabaho. Ang mga primitive na uri ay tumutulong sa laro na tumakbo nang mabilis, habang ang mga hindi primitive na uri ay tumutulong sa pag-aayos ng mga grupo ng impormasyon.
Balikan natin ang natutuhan natin sa araling ito:
Sa pamamagitan ng pag-unawa sa parehong primitive at non-primitive na mga uri ng data, natutunan mo kung paano iniisip at iniimbak ng mga computer ang impormasyon. Ang bawat uri ay may sariling espesyal na trabaho. Ang mga primitive na uri ng data ay mabilis at simple, habang ang mga hindi primitive na uri ay kapaki-pakinabang kapag kailangan mong ayusin ang mas malalaking set ng data.
Narito ang isang buod ng mga pangunahing punto na dapat mong tandaan mula sa araling ito:
Ginagamit ng computer ang mga ideyang ito upang mag-imbak at pamahalaan ang impormasyon. Ang bawat uri ay may tungkulin, tulad ng bawat tool sa isang toolbox na tumutulong sa iyo na bumuo ng isang bagay. Sa pamamagitan ng pag-aaral ng pagkakaiba sa pagitan ng primitive at non-primitive na uri ng data, ginagawa mo ang unang hakbang sa pag-unawa kung paano gumagana ang mga computer at kung paano bibigyan sila ng malinaw na mga tagubilin.
Kapag nag-explore ka pa tungkol sa mga computer at programming, makikita mo ang mga uri ng data na ito na ginagamit sa maraming program. Tumutulong sila sa paggawa ng mga video, laro, at maging ng mga app sa iyong telepono. Sa tuwing gagamit ka ng computer, ang mga ideyang ito ay gumagana sa likod ng mga eksena upang matiyak na ang lahat ay tumatakbo nang maayos.
Ipinakita sa iyo ng araling ito na kahit ang mga simpleng ideya ay may malaking epekto sa kung paano gumagana ang mga kumplikadong sistema. Ang mga primitive na uri ng data ay ang mga simpleng bloke ng gusali. Pinagsasama-sama ng mga hindi primitive na uri ng data ang mga bloke na iyon upang lumikha ng mga kamangha-manghang istruktura. Parehong mahalaga para sa paggawa ng mga program sa computer na makakalutas ng mga problema at nagpapakita ng magagandang resulta sa iyong screen.
Tandaan, tulad ng pagpili mo ng tamang laruan para sa paglalaro, pinipili ng mga programmer ang tamang uri ng data para sa bawat trabaho. Kapag nakakita ka ng integer o boolean, isipin ang mga ito bilang pang-araw-araw na item na madaling maunawaan. Kapag nakakita ka ng array o listahan, tandaan na para itong isang kahon na pinagsasama-sama ang maraming item.
Sa pamamagitan ng pag-alam sa mga pangunahing konseptong ito, natututo ka ng wika ng mga computer. Makakatulong sa iyo ang kaalamang ito na maunawaan ang mga mas advanced na paksa sa susunod. Sa tuwing magpo-program ka ng isang simpleng laro o isang maliit na proyekto, isipin kung paano mo ginagamit ang mga uri ng data na ito upang gawing malinaw ang iyong mga tagubilin at madali ang paggana ng computer.
Patuloy na galugarin, patuloy na magtanong, at tandaan na ang bawat malaking ideya ay nagsisimula sa mga simpleng hakbang. Ang mga primitive at non-primitive na uri ng data ay ang mga unang building block sa iyong paglalakbay sa computer programming.
Ngayong natutunan mo na ang tungkol sa primitive at non-primitive na uri ng data, makikita mo kung gaano kahalaga ang bawat uri. Nagbibilang ka man ng mga numero, nagsusulat ng mga salita, o nagpapangkat ng mga item, alam mo ang tamang uri ng data na gagamitin. Ito ay isang mahusay na kasanayan para sa sinumang gustong matuto nang higit pa tungkol sa mga computer at kung paano gumagana ang mga ito.
Magpatuloy sa paggalugad at magsaya sa mga konseptong ito. Tutulungan ka nilang maunawaan ang mas kumplikadong mga ideya habang lumalaki ka. Gumamit ng mga simpleng halimbawa sa iyong pang-araw-araw na buhay upang sumangguni muli sa mga araling ito. Tulad ng pag-aayos ng iyong mga laruan o libro, natututo kang ayusin ang impormasyon sa isang computer.
Salamat sa pagbabasa ng araling ito sa primitive at non-primitive na uri ng data. Tandaan ang mga puntong ito habang natututo ka pa tungkol sa computer programming at nasisiyahan sa paggawa ng sarili mong mga proyekto.
