Како подијелити жице у Рубиу

Ако унос корисника није једна реч или број, тај унос ће морати да буде разделити или се претворио у листу низова или бројева.

На пример, ако програм затражи ваше пуно име, укључујући средњу почетну, прво ће га морати поделити на три одвојена жице пре него што може да сарађује са вашим именом, именом и презименом. То се постиже коришћењем Стринг # сплит метод.

У свом најосновнијем облику, Стринг # сплит узима један аргумент: раздјелник поља као низ. Овај раздјелник ће бити уклоњен из излаза и вратит ће се низ низова подијељених на раздјелник.

Дакле, у следећем примеру, под претпоставком да корисник правилно унесе своје име, требали бисте добити три елемента Арраи од раскола.

#! / уср / бин / енв рубин
штампај "Које је твоје пуно име? "
фулл_наме = гет.цхомп
наме = пуно_име.сплит ('')
ставља "Ваше име је # {наме.фирст}"
ставља „Ваше презиме # {наме.ласт}“

Ако покренемо овај програм и унесемо име, добит ћемо неке очекиване резултате. Такође, имајте на уму то прво име

$ руби сплит.рб
Које је твоје име и презиме? Мицхаел Ц. Морин
Ваше име је Мицхаел
Ваше презиме је Морин

Међутим, Стринг # сплит је мало паметнији него што бисте мислили. Ако је аргумент за Стринг # сплит је низ, заиста то користи као разграничник, али ако је аргумент низ са једним размаком (као што смо користили), онда закључује да желите да се поделите на било коју количину белог простора и да такође желите да уклоните било који водећи бели простор.

Дакле, ако бисмо му дали мало неисправно стање попут

Мицхаел Ц. Морин

(са додатним размацима), затим Стринг # сплит и даље би урадила оно што се очекује. Међутим, то је једини посебан случај када прођете Низ као први аргумент. Раздјелници регуларне експресије

Такође можете пренијети регуларни израз као први аргумент. Ево, Стринг # сплит постаје мало флексибилнији. Такође можемо да учинимо мало паметнијим код за поделу имена.

Не желимо период на крају средњег иницијалног. Знамо да је средњи иницијал, а база података не жели период тамо, па га можемо уклонити док се делимо. Када Стринг # сплит одговара регуларном изразу, то чини исту ствар као да се управо подудара са разграничником низа: извлачи га из излаза и дели га у том тренутку.

Дакле, можемо мало еволуирати наш пример:

$ цат сплит.рб
#! / уср / бин / енв рубин
штампај "Које је твоје пуно име? "
фулл_наме = гет.цхомп
наме = фулл_наме.сплит (/ \.? \ с + /)
ставља "Ваше име је # {наме.фирст}"
ставља „Ваш средњи иницијал је # {наме [1]}“
ставља „Ваше презиме # {наме.ласт}“

Руби није заиста велика на „посебним променљивим“ које можете наћи на језицима попут Перл-а, али Стринг # сплит да ли користите оно што морате бити свесни. Ово је подразумевана променљива сепаратора записа, такође позната као $;.

То је глобално, нешто што не видите често у Рубију, па ако га промените, то би могло утицати на остале делове кода - само будите сигурни да ћете га вратити када завршите.

Међутим, све што користи ова променљива делује као задана вредност за први аргумент Стринг # сплит. Чини се да је ова променљива подразумевано постављена на нула. Међутим, ако Стринг # сплитПрви аргумент је нула, замениће га једним свемирским низом.

Ако је раздјелник прешао на Стринг # сплит тада је низ нулте дужине или регуларни израз Стринг # сплит ће се понашати мало другачије. Уклониће ништа од првобитног низа и поделити на сваки знак. Ово у суштини претвара низ у низ једнаких дужина који садржи само низове с једним знаком, по један за сваки знак у низу.

Ово може бити корисно за понављање низа и коришћено је у пре -9.9.к и пре-1.8.7 (који подржавају број функција од 1.9.к) за понављање знакова у низу без бриге о раскиду мултибајт Уницоде карактери. Међутим, ако стварно желите да поновите низ стрингова, а користите 1.8.7 или 1.9.к, вероватно би требало да користите Стринг # евери_цхар уместо тога.

#! / уср / бин / енв рубин
стр = "Претворила ме у невт!"
стр.сплит (''). сваки до | ц |
ставља ц
крај

Вратимо се нашем примеру рашчлањивања имена, шта ако неко има размак у презимену? На пример, холандска презимена често могу почети са "ван" (што значи "од" или "од").

Ми стварно желимо само 3 елемента низ, тако да можемо да користимо други аргумент Стринг # сплит које смо до сада игнорисали. Очекује се да ће други аргумент бити а Фикнум. Ако је овај аргумент позитиван, у већини случајева биће испуњено много елемената. Дакле, у нашем случају, ми бисмо желели да донесемо 3 за овај аргумент.

#! / уср / бин / енв рубин
штампај "Које је твоје пуно име? "
фулл_наме = гет.цхомп
наме = фулл_наме.сплит (/ \.? \ с + /, 3)
ставља "Ваше име је # {наме.фирст}"
ставља „Ваш средњи иницијал је # {наме [1]}“
ставља „Ваше презиме # {наме.ласт}“

Ако ово покренемо поново и дамо му холандско име, поступиће како се очекује.

$ руби сплит.рб
Које је твоје име и презиме? Винцент Виллем ван Гогх
Ваше име је Винцент
Ваш средњи иницијал је Виллем
Ваше презиме је Ван Гогх

Међутим, ако је овај аргумент негативан (било који негативан број), тада неће бити ограничења броја елементи у излазном пољу и било који крајњи разграничари ће се појављивати као жице нулте дужине на крају низ.

То је показано у овом ИРБ исечку:

: 001> "ово је, тест," тест .сплит (',', -1)
=> ["ово", "је", "а", "тест", "", "", "", ""