{"id":32091,"date":"2018-11-04T19:22:56","date_gmt":"2018-11-04T13:52:56","guid":{"rendered":"https:\/\/www.wikitechy.com\/technology\/?p=32091"},"modified":"2018-11-04T19:24:47","modified_gmt":"2018-11-04T13:54:47","slug":"work-with-string-methods-in-ruby","status":"publish","type":"post","link":"https:\/\/www.wikitechy.com\/technology\/work-with-string-methods-in-ruby\/","title":{"rendered":"To Work with String Methods in Ruby"},"content":{"rendered":"

Work with String Methods in Ruby<\/strong><\/span><\/p>\n

Introduction<\/span><\/h3>\n

Ruby<\/a> strings have several inbuilt ways that create it straightforward to switch and manipulate text, a standard task in several programs.<\/p>\n

You\u2019ll use string ways to see the length of a string<\/strong>, index and split strings to extract substrings,<\/strong> add and take away whitespace and alternative characters, amendment the case of characters in strings, and realize and replace text.<\/p>\n

When you are done, you will be ready to incorporate these ways into your own programs.<\/p>\n

Determining String Length<\/span><\/h3>\n

String methodology<\/strong> length returns the number of characters during a string<\/a>. This methodology is helpful for once you ought to enforce the minimum or most word lengths, or to truncate larger string<\/strong>s to be at intervals sure limits to be used as abbreviations.<\/p>\n

The example<\/strong> that prints the length of a sentence:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201dopen_source%20%3D%20%22Sammy%20contributes%20to%20open%20source.%22%0Aprint%20open_source.length\u201d message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n

Output:<\/span><\/h3>\n
33<\/pre>\n
Keep in mind that each character, together with letters, numbers, whitespace characters, and symbols<\/strong>, are counted since it\u2019s a part of the string.<\/p>\n
To check to examine if a string is empty<\/strong>, you\u2019ll check to examine if its length is zero, otherwise, you will use the empty?<\/strong> method:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201dname%20%3D%20%22%22%0Aname.empty%3F%20%20%20%20%23%20true%0A%0Aname%20%3D%20%22Sammy%22%0Aname.empty%3F%20%20%20%20%23%20false%0A%0Aname%20%3D%20%22%20%20%20%20%20%22%0Aname.empty%3F%20%20%20%20%23%20false\u201d message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
Let\u2019s check up on the way to we tend to index strings and access a string\u2019s contents.<\/p>\n
Accessing Characters at intervals a String<\/span><\/h3>\n
To print or work with a number of the characters<\/strong> during a string, use the slice methodology to urge the half you would like.<\/p>\n
Like arrays<\/a>, wherever every component corresponds to an index, every of a string\u2019s characters additionally corresponds to an index, beginning with the index zero.<\/p>\n
For the string Sammy<\/strong> the index breakdown sounds like this:<\/p>\n\n\n\n\n\n
o<\/strong><\/td>\n1<\/strong><\/td>\n2<\/strong><\/td>\n3<\/strong><\/td>\n4<\/strong><\/td>\n<\/tr>\n<\/thead>\n
S<\/td>\na<\/td>\nm<\/td>\nm<\/td>\ny<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Slice methodology allows you to grab one character or a variety of characters. Passing one whole number returns the character at that index. Passing 2 integers<\/strong>, separated by a comma, tells slice to come back all the characters from the primary index to the last index, inclusive. The slice methodology additionally accepts a variety, such as 1..4, to specify the characters to extract:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201d%22Sammy%22.slice(0)%20%20%20%20%20%23%20%22s%22%0A%22Sammy%22.slice(1%2C2)%20%20%20%23%20%22am%22%0A%22Sammy%22.slice(1..4)%20%20%23%20%22ammy%22\u2033 message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
The [ ] syntax is AN alias for the slice, therefore you\u2019ll treat strings like arrays:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201d%22Sammy%22%5B0%5D%20%20%20%20%20%23%20%22s%22%0A%22Sammy%22%5B1%2C2%5D%20%20%20%23%20%22am%22%0A%22Sammy%22%5B1..4%5D%20%20%23%20%22ammy%22\u2033 message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
You may also access one character from the tip of the string with a negative index. -1<\/strong> would allow you to access the last character of the string, -2<\/strong> would access the second-to-last, and so on.<\/p>\n
Finally, you\u2019ll convert the string to an array of characters with the chars method:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201d%22sammy%22.chars%20%20%20%20%23%20%5B%22S%22%2C%20%22a%22%2C%20%22m%22%2C%20%22m%22%2C%20%22y%22%5D\u201d message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
This will be helpful for manipulating or remodeling<\/strong> the characters within the string.<\/p>\n
Next, let\u2019s check up on the way to alter the case of the characters during a string.<\/p>\n
Converting to higher and lower-case letter<\/span><\/h3>\n
The upcase and downcase<\/strong> ways come back a string with all the letters of a creative string regenerate to upper- or lower-case letters. Any characters<\/a> within the string that aren\u2019t letters won\u2019t be modified.<\/p>\n
Let\u2019s convert the string Sammy Shark<\/strong> to be all higher case:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201dname%20%3D%20%22Sammy%20Shark%22%0Aprint%20name.upcase\u201d message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
Output:<\/span><\/h3>\n
SAMMY SHARK<\/pre>\n
Now, let\u2019s convert the string to be all lower case:<\/strong><\/p>\n[pastacode lang=\u201druby\u201d manual=\u201dprint%20name.downcase\u201d message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
Output:<\/span><\/h3>\n
SAMMY SHARK<\/pre>\n
Upcase and downcase functions<\/strong> create it easier to judge and compare strings by creating case consistent throughout. for instance, if you fire a username and therefore the user enters the username with a capital, you\u2019ll minuscule the user\u2019s input and compare it against a minuscule best-known price.<\/p>\n
Ruby strings<\/strong> even have a capitalize methodology that returns a replacement string with the primary character capitalized:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201d%22sammy%22.capitalize%20%20%20%20%23%20%22Sammy%22\u2033 message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
This may be a convenient methodology<\/strong>, however, use caution however you employ it; it solely capitalizes the primary letter, therefore, it\u2019d not perpetually match the employment case you would like.<\/p>\n
It additionally provides a swapcase methodology<\/strong> that returns a string with the casing swapped:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201dtext%20%3D%20%22Sammy%22%0Aprint%20text.swapcase\u201d message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
Output<\/span><\/h3>\n
sAMMY<\/code><\/pre>\n
The downcase, upcase, capitalize<\/strong> and swapcase<\/strong> ways all come back a replacement string and leave the present string unedited. this is often necessary to recollect if you are doing one thing aside from straight off printing out the text. Take a glance at the subsequent example:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201dtext%20%3D%20%22sammy%22%0Atext.capitalize%0A%0Aprint%20%22Hello%2C%20%23%7Btext%7D!%22\u2033 message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
Output:<\/span><\/h3>\n
Hello, sammy!<\/code><\/pre>\n
Even tho\u2019 we tend to know as exploit the text variable, we tend to ne\u2019er captured the worth came by capitalizing. We\u2019d rewrite the program like this:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201dtext%20%3D%20%22sammy%22%0Atext%20%3D%20text.capitalize%0A%0Aprint%20%22Hello%2C%20%23%7Btext%7D!%22\u2033 message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
Output:<\/span><\/h3>\n
Hello, Sammy!<\/code><\/pre>\n
You will use downcase!, upcase!, capitalize! and swapcase!<\/strong> to switch the first string instead:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201dtext%20%3D%20%22sammy%22%0Atext%20%3D%20text.capitalize!%0A%0Aprint%20%22Hello%2C%20%23%7Btext%7D!%22\u2033 message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
Be careful<\/strong> tho\u2019. There area unit disadvantages to mutating the first string. Ruby provides each way, therefore, you\u2019ll opt for the one that matches your wants.<\/p>\n
Now let\u2019s add and take away whitespace from strings.<\/p>\n
Padding and baring Strings<\/span><\/h3>\n
If you are writing a program that has got to format some text, you may typically realize that you will need to feature some area before of, after, or around a string so as to form it line up with alternative information.<\/p>\n
And alternative times, you will need to get rid of gratuitous characters<\/strong> from the start or finish of your strings, like additional whitespace or special characters.<\/p>\n
To surround a string with areas<\/strong>, use the middle method:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201d%22Sammy%22%2Ccenter(21)%20%20%20%20%23%20%22%20%20%20%20%20%20%20%20Sammy%20%20%20%20%20%20%20%20%22\u2033 message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
You will specify a string because of the second argument<\/strong> if you wish to use a distinct character:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201d%22%20%5BSammy%5D%20%22.center(21%2C%20%22%3C%3E%22)%20%20%20%23%20%22%3C%3E%3C%3E%3C%3E%20%5BSammy%5D%20%3C%3E%3C%3E%3C%3E%22\u2033 message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
The ljust and rjust<\/strong> ways add areas or characters to the left or right facet<\/strong> of a string and work specifically just like the center method:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201d%22Sammy%22.ljust(20)%20%20%20%20%20%20%20%20%20%23%20%22Sammy%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%22%0A%22Sammy%22.rjust(20)%20%20%20%20%20%20%20%20%20%23%20%22%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20Sammy%22%0A%22Sammy%22.rjust(20%2C%20%22!%22)%20%20%20%20%23%20%22!!!!!!!!!!!!!!!Sammy%22\u2033 message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
To take away leading areas from a string, use the rstrip methodology<\/strong>. To get rid of trailing areas, use lstrip. Use strip to get rid of each leading and trailing spaces:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201d%22%20%20%20%20%20%20%20%20Sammy%22.rstrip%20%20%20%20%23%20%22Sammy%22%0A%22Sammy%20%20%20%20%20%20%20%20%22.lstrip%20%20%20%20%23%20%22Sammy%22%0A%22%20%20%20%20%20%20Sammy%20%20%22.strip%20%20%20%20%20%23%20%22Sammy%22\u2033 message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
You will use the center!, ljust!, rjust!, lstrip!, rstrip!, and strip!<\/strong> ways to switch the first string.<\/p>\n
Sometimes you\u2019ll have to get rid of characters from the tip of a string<\/strong>. Ruby\u2019s chop methodology<\/strong> will simply that; it removes the last character from a string:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201d%22Sammy%22.chop%20%20%20%20%20%23%20%22Samm%22\u2033 message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
This is particularly helpful for removing the newline character<\/strong> (\\n) from strings:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201d%22This%20string%20has%20a%20newline%5Cn%22.chop\u201d message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
The chop methodology<\/strong> leaves the first string intact, returning a replacement string. The chop! methodology modifies the present string in situ.<\/p>\n
The chomp methodology will take away multiple characters from the tip of a string:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201d%22Sammy%22.chomp(%22my%22)%20%20%20%20%23%20%22Sam%22\u2033 message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
If you do not specify a string to get rid of, chomp<\/strong> can take away the newline:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201d%22This%20string%20has%20a%20newline%5Cn%22.chomp%20%20%20%23%20%22This%20string%20has%20a%20newline\u201d message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
However, if the string does not contain a newline character<\/strong>, chomp simply returns the first string:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201d%22Sammy%22.chomp%20%20%20%20%20%23%20%22Sammy%22\u2033 message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
This makes chomp a touch safer to use once removing newlines than the chop methodology, that perpetually removes the last character.<\/p>\n
Ruby contains a chomp!<\/strong> a methodology that mutates the first string and returns the modified string if it performed a replacement. However, not like chomp, the chomp! methodology returns null if it did not alter the string:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201dstring%20%3D%20%22Hello%5Cn%22%0Astring.chomp!%20%20%20%20%20%23%20%22Hello%22%0A%0Astring%20%3D%20%22Hello%22%0Astring.chomp!%20%20%20%20%20%23%20nil\u201d message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
Next, let\u2019s check up on the way to seek for text in strings.<\/p>\n
Finding Characters and Text<\/span><\/h3>\n
Sometimes you would like to see whether or not or not a string contains another string.<\/p>\n
The include?<\/strong> methodology checks to examine if a string contains another string. It returns true if the string exists and false if not:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201d%22Sammy%22.include%3F(%22a%22)%20%20%20%23%20true%0A%22Sammy%22.include%3F(%22b%22)%20%20%20%23%20false\u201d message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
The index methodology<\/strong> returns the index of a personality. It may also establish the index of the primary character of a substring. And it returns null if the character or substring does not exist:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201d%22Sammy%22.index(%22a%22)%20%20%20%20%20%23%201%0A%22Sammy%22.index(%22mm%22)%20%20%20%20%23%202%0A%22Sammy%22.index(%22Fish%22)%20%20%23%20nil\u201d message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
The index methodology<\/strong> solely finds the primary occurrence tho\u2019. Here\u2019s AN example with an extended string:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201dtext%20%3D%20%22Sammy%20contains%20a%20balloon%22%0Atext.index(%22a%22)%20%20%20%20%23%201\u2033 message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
The string Sammy<\/strong> contains a balloon has four occurrences of the letter \u201ca\u201d. However, index solely found the primary occurrance. you will have to jot down one thing a lot of specific to find one amongst the opposite occurrances.<\/p>\n
For example, you may convert the string to AN array of characters and use array ways to tell through the results and choose the indices for the character. Here\u2019s one methodology for doing that:<\/p>\n
[1, 7, 10, 13]<\/code><\/pre>\n
each_with_index<\/strong> returns a two-dimensional array containing the an entry for every character and its index. choose whittles it all the way down to simply the entries wherever the character may be a, and map converts the 2-dimensional array into a one-dimensional array of the indices.<\/p>\n
In addition to trying to find characters during a string, you\u2019ll check to examine if a string starts with a personality or substring victimization the start_with? method:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201dtext%20%3D%20%22Sammy%20contains%20a%20balloon%22%0Atext.start_with%3F(%22s%22)%20%20%20%20%20%20%20%20%20%23%20true%0Atext.start_with%3F(%22Sammy%20has%22%20%20%23%20true\u201d message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
The start_with?<\/strong> methodology accepts multiple strings and returns true if any of them match:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201dtext%20%3D%20%22Sammy%20contains%20a%20balloon%22%0Atext.start_with%3F(%22Sammy%20the%20Shark%22%2C%20%22Sammy%22)%20%23%20true\u201d message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
In this instance, \u201cSammy the Shark<\/strong>\u201d is not found, however, \u201cSammy\u201d<\/strong> is, therefore the comeback price is true.<\/p>\n
You will use the end_with?<\/strong> methodology to examine if a string ends with the given substring. It works specifically like start_with?:<\/strong><\/p>\n[pastacode lang=\u201druby\u201d manual=\u201dtext%20%3D%20%22Sammy%20contains%20a%20balloon%22%0Atext.end_with%3F(%22balloon%22)%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20true%0Atext.end_with%3F(%22boomerang%22)%20%20%20%20%20%20%20%20%20%20%20%20%20%23%20false%0Atext.end_with%3F(%22boomerang%22%2C%20%22balloon%22)%20%20%23%20tru\u201d message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
We\u2019ve checked out ways that to search out text, therefore let\u2019s check up on the way to replace that text with completely different text.<\/p>\n
Replacing Text in Strings<\/span><\/h3>\n
The realize and replace feature<\/em> in word processors allows you to seek for a string and replace it with another string. you\u2019ll try this in Ruby with the sub and gsub ways.<\/p>\n
The sub methodology<\/strong> replaces a part of a string with another.<\/p>\n
Sammy now not has the balloon; it flew away. Let\u2019s amendment the substring \u201chas\u201d to \u201chad\u201d.<\/strong><\/p>\n[pastacode lang=\u201druby\u201d manual=\u201dballoon%20%3D%20%22Sammy%20contains%20a%20balloon%22%0Aprint%20balloon.sub(%22has%22%2C%22had%22)\u201d message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
Output<\/span><\/h3>\n
Sammy had a balloon.<\/code><\/pre>\n
The sub methodology<\/strong> solely replaces the primary occurrence of the match with the new text. Let\u2019s use a changed string that has 2 occurrences of the word has:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201dballoon%20%3D%20%22Sammy%20has%20a%20balloon.%20The%20balloon%20has%20a%20ribbon%22%0Aprint%20balloon.sub(%22has%22%2C%22had%22)\u201d message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
Output<\/span><\/h3>\n
Sammy had<\/span> a balloon. The balloon has a ribbon<\/code><\/pre>\n
Only the primary occurrence<\/strong> modified.<\/p>\n
To amendment all of them, use the gsub methodology, that performs international substitution:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201dballoon%20%3D%20%22Sammy%20has%20a%20balloon.%20The%20balloon%20has%20a%20ribbon%22%0Aprint%20balloon.gsub(%22has%22%2C%22had%22)\u201d message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
Output:<\/span><\/h3>\n
Sammy had<\/span> a balloon. The balloon had<\/span> a ribbon<\/code><\/p>\n
The sub and gsub<\/strong> ways perpetually come back new strings, departure the originals unqualified. Let\u2019s demonstrate this by ever-changing \u201cballoon\u201d to \u201cboomerang\u201d in our string:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201dtext%20%3D%20%22Sammy%20has%20a%20balloon%22%0Atext.gsub(%22ballooon%22%2C%20%22boomerang%22)%0Aprint%20text\u201d message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
Output:<\/span><\/h3>\n
Sammy has a balloon<\/code><\/p>\n
The output does not show the result we\u2019re trying to find, as a result of whereas we tend to did specify the substitution, we tend to never assign gsub to a replacement variable. to urge the result we\u2019d like, we tend to may rewrite the program like this:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201dtext%20%3D%20%22Sammy%20has%20a%20balloon%22%0Atext%20%3D%20text.sub(%22ballooon%22%2C%20%22boomerang%22)%0Aprint%20text\u201d message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
Alternatively, you\u2019ll use sub!<\/strong> instead, that modifies the first string. Let\u2019s do this by doing a handful of string replacements. We\u2019ll amendment \u201cred balloon\u201d to \u201cblue boomerang\u201d:<\/strong><\/p>\n[pastacode lang=\u201druby\u201d manual=\u201dtext%20%3D%20%22Sammy%20has%20a%20red%20balloon%22%0Atext.sub!(%22red%22%2C%20%22blue%22)%0Atext.sub!(%22balloon%22%2C%20%22boomerang%22)%0Aprint%20text\u201d message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
Output:<\/span><\/h3>\n
Sammy has a blue boomerang<\/code><\/pre>\n
You will use the gsub! methodology<\/strong> to try to to a worldwide substitution in situ further.<\/p>\n
The sub and gsub ways settle for regular expressions for the search pattern. Let\u2019s replace all the vowels within the string with the @ symbol:<\/strong><\/p>\n[pastacode lang=\u201druby\u201d manual=\u201d%22Sammy%20has%20a%20red%20balloon%22.gsub%20%2F%5Baeiou%5D%2F%2C%20%22%40%22\u2033 message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n[pastacode lang=\u201druby\u201d manual=\u201d%22S%40mmy%20h%40s%20%40%20r%40d%20b%40ll%40%40n%22\u2033 message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
The replacement price does not need to be a string. You\u2019ll use a hash to specify however individual characters or items ought to get replaced. Let\u2019s replace all occurrences of the letter a with @ a<\/strong>nd every one the o characters with zeros:<\/p>\n[pastacode lang=\u201druby\u201d manual=\u201d%22Sammy%20has%20a%20red%20balloon%22.gsub%20%2F%5Baeiou%5D%2F%2C%20%7B%22a%22%20%3D%3E%20%22%40%22%2C%20%22o%22%20%3D%3E%20%220%22%7D%0A%23%20%22S%40mmy%20h%40s%20%40%20rd%20b%40ll00n%22\u2033 message=\u201d\u201d highlight=\u201d\u201d provider=\u201dmanual\u201d\/]\n
You will use this to perform a lot of advanced substitutions with less code.<\/p>\n
Conclusion<\/span><\/h3>\n
You worked with and manipulated strings<\/strong> victimization a number of the inbuilt ways for the string information kind. you furthermore might learn that a lot of the ways for operating with strings are available 2 variants: one that leaves the string unchanged, and one that modifies the first string.<\/strong> that one you employ depends on your wants. Ruby provides you the flexibleness to decide on however you wish to figure together with your information. However, writing code that does not modify existing information will be easier to right later.<\/p>\n","protected":false},"excerpt":{"rendered":"
Work with String Methods in Ruby Introduction Ruby strings have several inbuilt ways that create it straightforward to switch and manipulate text, a standard task in several programs. You\u2019ll use string ways to see the length of a string, index and split strings to extract substrings, add and take away whitespace and alternative characters, amendment […]<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[86323,83549],"tags":[86324,86325,86326,86327,86328,86329,86330,86331,86332,86334,86333,86335,86337,86336,86338,86339],"class_list":["post-32091","post","type-post","status-publish","format-standard","hentry","category-ruby","category-strings","tag-ruby-index-of-string","tag-ruby-remove-characters-from-beginning-of-string","tag-ruby-remove-characters-from-end-of-string","tag-ruby-remove-characters-from-string","tag-ruby-remove-characters-from-string-regex","tag-ruby-remove-substring","tag-ruby-replace-character-in-string","tag-ruby-replace-multiple-characters-in-string","tag-ruby-replace-substring","tag-ruby-split","tag-ruby-string-concatenation","tag-ruby-string-contains","tag-ruby-string-gsub","tag-ruby-string-replace","tag-ruby-substring-from-character","tag-ruby-substring-to-end"],"_links":{"self":[{"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/posts\/32091","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/comments?post=32091"}],"version-history":[{"count":0,"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/posts\/32091\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/media?parent=32091"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/categories?post=32091"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.wikitechy.com\/technology\/wp-json\/wp\/v2\/tags?post=32091"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}