Paano Suriin Kung Ang Isang String ay Naglalaman ng isang Substring sa Bash

String ng Escaping Spaces

Maaaring maitayo ang isang string sa pamamagitan ng pagpapalit ng bawat puwang ng pagkakasunud-sunod ng space escape, ‘’; tulad ng sa:

Ang output ay:

Ang turismo sa Egypt ay isa sa mga nangungunang industriya ng ekonomiya sa bansa.

Tandaan: ginamit din ng apostrophe ang pagkakasunud-sunod ng space escape.

String ng Single Quotes

Mayroon bang oras ang programmer upang makatakas sa lahat ng mga puwang sa isang string? Hindi. Samakatuwid, ang paggamit ng dalawang solong quote upang maibawas ang isang string ay mas mahusay; tulad ng:

Ang isang solong-quote na string ay hindi pinapayagan ang paglawak (kapalit ng epekto nito) ng anumang pagkakasunud-sunod ng pagtakas. Sa kasamaang palad, kung ang dalawang mga string ay naka-code sa tabi ng bawat isa, dadalhin sila bilang isang string. Ang isang pagkakasunud-sunod ng pagtakas ay maaaring ipasok sa pagitan, tulad ng ginagawa sa itaas. Ang pagkakasunud-sunod ng pagtakas ay lalawak. Kaya't ang output ay magiging:

Ang turismo sa Egypt ay isa sa mga nangungunang industriya ng ekonomiya sa bansa.

String ng Double Quote

Sa mga dobleng quote, ang mga pagkakasunud-sunod ng pagtakas ay hindi pinalawak din, ngunit ang mga variable ay pinalawak. Ang sumusunod na code ay naglalarawan nito:

Ang output ay:

Ang turismo sa Egypt ay isa sa mga nangungunang industriya ng ekonomiya sa bansa.

Tandaan: ginamit din ng apostrophe ang pagkakasunud-sunod ng space escape.

Sa artikulong ito, ang pangunahing uri ng string na isinasaalang-alang ay ang string sa iisang mga quote.

Mga Batayan ng Regular na Pagpapahayag

Regex

Isaalang-alang ang string na ito:

Ang mundong ito ay hindi talaga ang tahanan natin.

Hayaan ang mundo na ang substring ng interes. Pagkatapos, ang malaking string (buong string) ay tinatawag na target string o simpleng, ang target. Ang 'mundo' sa mga quote ay tinatawag na regular na expression o simple, regex. Ang nilalaman, mundo, ang pattern, sa kasong ito.

Simpleng Pagtutugma

Sa sumusunod na code, kung ang salitang 'mundo' ay matatagpuan sa target, sasabihin namin na ang salita ay naitugma.

Ang = ~, na kung saan ay ang operator ng pagtatalaga na sinusundan ng ~, ay tinawag na nagbubuklod na operator. Sinusuri ng kundisyon kung ang pattern ay naitugma sa target na string. Kung ang isang substring na naaayon sa pattern ay matatagpuan sa target, nahanap ang ipinakitang pahayag ng echo. Kung hindi ito nahanap, hindi nahanap ang pahayag ng echo na hindi nakita. Ang output para sa code na ito ay:

natagpuan

Tulad ng pattern, mundo, ay matatagpuan sa target. Tandaan na ang delimiting space pagkatapos ng [[at bago]] ay napanatili.

Pattern

Sa code sa itaas, ang 'mundo' sa mga quote ay ang regex habang ang mundo mismo ang pattern. Ito ay isang prangka na pattern. Gayunpaman, karamihan sa mga pattern ay hindi ganoong kadali. Ang isang pattern ay isang paglalarawan ng isang substring na matatagpuan. At sa gayon, ang pattern ng Bash ay gumagamit ng ilang mga metacharacter. Ang isang metacharacter ay isang character tungkol sa iba pang mga character. Halimbawa, ang Bash Pattern ay gumagamit ng mga sumusunod na metacharacter:

^ $ . * +? () [] {} |

Ang isang regular na expression ay maaari ding mai-type sa kundisyon ng dobleng mga braket. Ngunit hindi ito kailangang maging sa mga quote. Kaya, sa kasong ito, ito ay literal, isang pattern.

Mga Klase ng Character

Mga Square Bracket

Ang output ng sumusunod na code ay natagpuan, nangangahulugang isang tugma ang naganap:

Ang pattern, [cbr] at ay tumugma sa pusa, na nagsisimula sa 'c', at kung saan ay nagpapatuloy at nagtatapos sa. [cbr] sa ibig sabihin, tumugma sa 'c' o 'b' o 'r' na sinusundan ng at.

Ang output ng sumusunod na code ay natagpuan, nangangahulugang isang tugma ang naganap:

Ang pattern, [cbr] at ay tumutugma sa bat, na nagsisimula sa 'b', at kung saan ay nagpapatuloy at nagtatapos sa. [cbr] sa ibig sabihin, tumugma sa 'c' o 'b' o 'r' na sinusundan ng at.

Ang output ng sumusunod na code ay natagpuan, nangangahulugang isang tugma ang naganap:

Ang pattern, [cbr] at ay tumutugma sa daga, na nagsisimula sa ‘r’, at kung saan ay nagpapatuloy at nagtatapos sa.

Sa mga sample ng code sa itaas, hindi alam ng programmer kung mayroon ang pusa o bat o daga sa target na string. Ngunit, alam niya na ang substring ay nagsisimula sa alinman sa 'c' o 'b' o 'r', pagkatapos ay nagpapatuloy at nagtatapos sa. Ang mga square bracket sa isang pattern ay nagbibigay-daan sa iba't ibang posibleng mga character na tumugma sa isang character sa isang posisyon na may kaugnayan sa iba sa target. Kaya, ang mga square bracket ay naglalaman ng isang hanay ng mga character, kung saan ang isa ay naitugma para sa isang substring. Panghuli, ito ay ang kumpletong substring na naitugma.

Saklaw ng Mga Character

Sa itaas na code [cbr] ay isang klase. Kahit na ang 'c' o 'b' o 'r' ay tumutugma sa isang solong character, kung sa sumusunod na kaagad ay hindi tumutugma, ang pattern ay hindi tutugma sa anumang bagay.

Sa gayon, may ilang mga saklaw na bubuo sa isang klase. Halimbawa, 0 hanggang 9 na mga digit ang bumubuo sa klase, [0-9] na may kasamang 0 at 9. Ang maliit na maliit na 'a' hanggang 'z' ay bumubuo sa klase [a-z] na may kasamang 'a' at 'z'. Ang uppercase 'A' hanggang 'Z' ay bumubuo sa klase [A-Z] na may kasamang 'A' at 'Z'. Mula sa isang klase, ito ay isa sa mga character na tutugma sa isang character sa string.

Ang sumusunod na code ay gumagawa ng isang tugma:

Sa oras na ito ang target ay isang literal na string sa kundisyon. Ang 8, na isa sa mga posibleng numero sa loob ng saklaw, [0-9], ay tumugma sa 8 sa string, 'ID8id'. Ang code sa itaas ay katumbas ng:

Dito, ang lahat ng mga posibleng numero ay nakasulat sa pattern, kaya walang gitling.

Sa sumusunod na code, nakuha ang isang tugma:

Ang laban ay nasa pagitan ng maliliit na ‘i’ ng saklaw, [a-z], at maliit na maliit na ‘i’ ng target na string, ‘ID8iD’.

Tandaan: ang saklaw ay isang klase. Ang klase ay maaaring maging bahagi ng isang mas malaking pattern. Kaya sa isang pattern, ang teksto ay maaaring nasa harap at / o pagkatapos ng klase. Ang sumusunod na code ay naglalarawan nito:

Ang output ay: natagpuan. Ang 'ID8id' mula sa pattern ay tumugma sa 'ID8id' sa target na string.

Negasyon

Ang pagtutugma ay hindi nakuha mula sa sumusunod na code:

Ang output ay:

hindi mahanap

Kung walang ^ sa harap ng saklaw, sa loob ng mga square bracket, ang zero ng saklaw ay tumutugma sa unang zero ng target na string. Kaya, ^ sa harap ng isang saklaw (o mga opsyonal na character) ay tinatanggihan ang klase.

Ang sumusunod na code ay gumagawa ng isang tugma sapagkat bumabasa ang kundisyon: tumugma sa anumang di-digit na character saanman sa target:

Kaya ang output ay: natagpuan.

Ang ibig sabihin ng [^ 0-9] ay isang hindi digit, kaya ang [^ 0-9] ay ang pagtanggi ng [0-9].

Ang ibig sabihin ng [^ a-z] ay isang hindi maliit na titik, sa gayon ang [^ a-z] ay ang pagwawaksi ng [a-z].

Ang ibig sabihin ng [^ A-Z] ay isang hindi malalaking titik, sa gayon ang [^ A-Z] ay ang pagtanggi ng [A-Z].

Ang iba pang mga negasyon ay magagamit.

Ang Panahon (.) Sa Huwaran

Ang panahon (.) Sa pattern ay tumutugma sa anumang character kasama ang sarili nito. Isaalang-alang ang sumusunod na code:

Ang output ng code ay natagpuan dahil tumutugma ang iba pang mga character. Ang isang tuldok ay tumutugma sa '5'; isa pang tuldok na tumutugma sa 'X'; at ang huling tuldok ay tumutugma sa isang tuldok.

Pagtutugma ng Kahalili

Isaalang-alang ang pangungusap na ito para sa isang target na string:

Ang hawla ay may mga ibon ng iba't ibang uri.

Maaaring may nais na malaman kung ang target na ito ay may kalapati o peacock o agila. Maaaring gamitin ang sumusunod na code:

Ang output ay, natagpuan. Ang alternatibong metacharacter, | ay nagtrabaho. Maaaring may dalawa, tatlo, apat at higit pang mga kahalili. Ang tumutugma sa code na ito ay 'peacock'.

Pagpapangkat

Sa sumusunod na pattern, ang panaklong ay ginamit upang pangkatin ang mga character:

isang entablado (mananayaw)

Ang pangkat dito ay isang mananayaw sa entablado na napapalibutan ng mga metacharacter (at). Ang (dancer) ay isang subgroup, habang ang isang entablado (dancer) ay ang buong pangkat. Isaalang-alang ang mga sumusunod:

Ang (mahusay na mananayaw)

Dito, ang subgroup o substring ay, ang dancer ay kasindak-sindak.

Ang mga substring na may Karaniwang Mga Bahagi

Ang isang stakeholder ay isang taong may interes sa isang negosyo. Mag-isip ng isang negosyo na may isang website, stake.com. Isipin na ang isa sa mga sumusunod na target na string ay nasa computer:

Ang website, stake.com ay para sa negosyo.;

Mayroong stakeholder.;

Gumagawa ang stakeholder para sa stake.com.;

Hayaan ang alinman sa mga string na ito ang maging target. Maaaring nais malaman ng programmer kung ang stake.com o stakeholder ay nasa anumang string ng target. Ang kanyang pattern ay:

stake.com | stakeholder

gumagamit ng paghahalili.

ang pusta ay nai-type nang dalawang beses sa dalawang salita. Maiiwasan ito sa pamamagitan ng pagta-type ng pattern tulad ng sumusunod:

stake (.com | may hawak)

Ang may hawak ng .com | ang subgroup sa kasong ito.

Tandaan: ang paggamit ng character na paghahalili sa kasong ito. hahanapin pa rin ang stake.com o stakeholder. Ang output ng sumusunod na code ay matatagpuan:

Ang tugma na substring dito ay stake.com.

Ang BASH_REMATCH Predefined Array

Ang BASH_REMATCH ay isang paunang natukoy na array. Ipagpalagay na ang isang pattern ay may mga pangkat. Tumugma ang buong pangkat, papunta sa cell para sa index 0 ng array na ito. Ang unang subgroup na tumugma, pumupunta sa cell para sa index 1; ang pangalawang subgroup na tumugma, pumapasok sa cell para sa index 2, at iba pa. Ipinapakita ng sumusunod na code kung paano gamitin ang array na ito:

Ang output ay:

natagpuan
mananayaw sa entablado, mananayaw,

Ang buong pangkat ay mananayaw sa entablado. Mayroon lamang isang subgroup, na kung saan ay dancer.

Tandaan: ang puwang sa pattern ay nakatakas.

Mataas / Mababang Kaso ng Pagtutugma ng Kalayaan

Ang pagtutugma, tulad ng ipinaliwanag sa itaas, ay sensitibo sa kaso. Ang pagtutugma ay maaaring gawin nang nakapag-iisa sa kaso. Ito ay nakalarawan sa sumusunod na code:

Ang output ay: natagpuan. Ang pattern ay, GoOd. Ang substring na naitugma ay 'mabuti'. Tandaan kung paano pinagana ang pagpipiliang nocasematch sa simula ng segment ng code at hindi pinagana sa dulo ng segment ng code.

Haba ng isang String

Ang syntax upang makuha ang haba ng isang string ay:

Halimbawa:

Ang output ay: 19.

Pagbawas ng String

Ang mga syntax para sa pagbawas ng string ay:

kung saan ang pagbibilang para sa OFFSET ay nagsisimula mula sa zero.

Ipinapakita ng sumusunod na halimbawa kung paano alisin ang unang 11 mga character ng isang string:

Ang output ay:

ance sa mahusay na musika.

Nagbibilang para sa LENGTH, nagsisimula mula sa susunod na character. Ipinapakita ng sumusunod na code kung paano maaaring payagan ang isang bahagi sa loob ng string:

Ang output ay:

ance t

Ang unang 11 character ay tinanggal; pinapayagan ang susunod na 6 na mga character, at ang natitirang mga character ay awtomatikong tinanggal.

Maghanap at Palitan

Kapag natagpuan ang isang substring, maaari itong mapalitan ng isa pang substring. Ang mga syntax para dito ay:

Para sa unang syntax na may solong forward slash, ang unang tugma lamang ang napalitan. Halimbawa:

Ang output ay:

Mayroong daga, bat at pusa, sa silid.
Mayroong isang malaking baka, bat at pusa, sa silid.

Para sa pangalawang syntax na may mga double forward slash, ang lahat ng mga paglitaw ng tugma ay pinalitan. Halimbawa:

Ang output ay:

Mayroong daga, bat at pusa, sa silid.
Mayroong isang malaking baka, isang malaking baka at isang malaking baka, sa silid.

Para sa pangatlong syntax na may solong forward slash, walang kapalit para sa una at tanging tugma.

Gayundin, ang unang nahanap na substring ay tinanggal. Halimbawa:

Para sa ika-apat na syntax na may dobleng pasulong na mga slash, walang kapalit para sa lahat ng mga tugma. Gayundin, ang lahat ng mga natagpuang substring ay tinanggal. Halimbawa:

Ang output ay:

Mayroong daga, bat at pusa, sa silid.
Mayroong a, a at a, sa silid.

Konklusyon

Upang masuri kung ang isang string ay may isang substring sa Bash, dapat gamitin ang Pagtutugma sa pattern. Ang Pagtutugma sa pattern ay hindi lamang nagaganap sa kundisyon ng dobleng mga braket, [[. . . ]] Maaari rin itong maganap sa pagpapalawak ng parameter, kasama ang $ {. . .} Sa pagpapalawak ng parameter, posible na makakuha ng isang substring ng mga index.

Ang ipinakita sa artikulong ito ay ang pinaka-kritikal na mga punto sa Pagtutugma sa pattern. Marami pa! Gayunpaman, kung ano ang susunod na dapat pag-aralan ng mambabasa, ay Pagpapalawak ng Filename.