{"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’ll 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=”ruby” manual=”open_source%20%3D%20%22Sammy%20contributes%20to%20open%20source.%22%0Aprint%20open_source.length” message=”” highlight=”” provider=”manual”\/]\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’s a part of the string.<\/p>\n
To check to examine if a string is empty<\/strong>, you’ll check to examine if its length is zero, otherwise, you will use the empty?<\/strong> method:<\/p>\n[pastacode lang=”ruby” manual=”name%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” message=”” highlight=”” provider=”manual”\/]\n
Let’s check up on the way to we tend to index strings and access a string’s 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=”ruby” manual=”%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″ message=”” highlight=”” provider=”manual”\/]\n
The [ ] syntax is AN alias for the slice, therefore you’ll treat strings like arrays:<\/p>\n[pastacode lang=”ruby” manual=”%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″ message=”” highlight=”” provider=”manual”\/]\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’ll convert the string to an array of characters with the chars method:<\/p>\n[pastacode lang=”ruby” manual=”%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” message=”” highlight=”” provider=”manual”\/]\n
This will be helpful for manipulating or remodeling<\/strong> the characters within the string.<\/p>\n
Next, let’s 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’t letters won’t be modified.<\/p>\n
Let\u2019s convert the string Sammy Shark<\/strong> to be all higher case:<\/p>\n[pastacode lang=”ruby” manual=”name%20%3D%20%22Sammy%20Shark%22%0Aprint%20name.upcase” message=”” highlight=”” provider=”manual”\/]\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=”ruby” manual=”print%20name.downcase” message=”” highlight=”” provider=”manual”\/]\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’ll minuscule the user’s 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=”ruby” manual=”%22sammy%22.capitalize%20%20%20%20%23%20%22Sammy%22″ message=”” highlight=”” provider=”manual”\/]\n
This may be a convenient methodology<\/strong>, however, use caution however you employ it; it solely capitalizes the primary letter, therefore, it’d 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=”ruby” manual=”text%20%3D%20%22Sammy%22%0Aprint%20text.swapcase” message=”” highlight=”” provider=”manual”\/]\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=”ruby” manual=”text%20%3D%20%22sammy%22%0Atext.capitalize%0A%0Aprint%20%22Hello%2C%20%23%7Btext%7D!%22″ message=”” highlight=”” provider=”manual”\/]\n
Output:<\/span><\/h3>\n
Hello, sammy!<\/code><\/pre>\n
Even tho’ we tend to know as exploit the text variable, we tend to ne’er captured the worth came by capitalizing. We’d rewrite the program like this:<\/p>\n[pastacode lang=”ruby” manual=”text%20%3D%20%22sammy%22%0Atext%20%3D%20text.capitalize%0A%0Aprint%20%22Hello%2C%20%23%7Btext%7D!%22″ message=”” highlight=”” provider=”manual”\/]\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=”ruby” manual=”text%20%3D%20%22sammy%22%0Atext%20%3D%20text.capitalize!%0A%0Aprint%20%22Hello%2C%20%23%7Btext%7D!%22″ message=”” highlight=”” provider=”manual”\/]\n
Be careful<\/strong> tho’. There area unit disadvantages to mutating the first string. Ruby provides each way, therefore, you’ll opt for the one that matches your wants.<\/p>\n
Now let’s 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=”ruby” manual=”%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″ message=”” highlight=”” provider=”manual”\/]\n
You will specify a string because of the second argument<\/strong> if you wish to use a distinct character:<\/p>\n[pastacode lang=”ruby” manual=”%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″ message=”” highlight=”” provider=”manual”\/]\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=”ruby” manual=”%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″ message=”” highlight=”” provider=”manual”\/]\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=”ruby” manual=”%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″ message=”” highlight=”” provider=”manual”\/]\n
You will use the center!, ljust!, rjust!, lstrip!, rstrip!, and strip!<\/strong> ways to switch the first string.<\/p>\n
Sometimes you’ll have to get rid of characters from the tip of a string<\/strong>. Ruby’s chop methodology<\/strong> will simply that; it removes the last character from a string:<\/p>\n[pastacode lang=”ruby” manual=”%22Sammy%22.chop%20%20%20%20%20%23%20%22Samm%22″ message=”” highlight=”” provider=”manual”\/]\n
This is particularly helpful for removing the newline character<\/strong> (\\n) from strings:<\/p>\n[pastacode lang=”ruby” manual=”%22This%20string%20has%20a%20newline%5Cn%22.chop” message=”” highlight=”” provider=”manual”\/]\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=”ruby” manual=”%22Sammy%22.chomp(%22my%22)%20%20%20%20%23%20%22Sam%22″ message=”” highlight=”” provider=”manual”\/]\n
If you do not specify a string to get rid of, chomp<\/strong> can take away the newline:<\/p>\n[pastacode lang=”ruby” manual=”%22This%20string%20has%20a%20newline%5Cn%22.chomp%20%20%20%23%20%22This%20string%20has%20a%20newline” message=”” highlight=”” provider=”manual”\/]\n
However, if the string does not contain a newline character<\/strong>, chomp simply returns the first string:<\/p>\n[pastacode lang=”ruby” manual=”%22Sammy%22.chomp%20%20%20%20%20%23%20%22Sammy%22″ message=”” highlight=”” provider=”manual”\/]\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=”ruby” manual=”string%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” message=”” highlight=”” provider=”manual”\/]\n
Next, let’s 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=”ruby” manual=”%22Sammy%22.include%3F(%22a%22)%20%20%20%23%20true%0A%22Sammy%22.include%3F(%22b%22)%20%20%20%23%20false” message=”” highlight=”” provider=”manual”\/]\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=”ruby” manual=”%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” message=”” highlight=”” provider=”manual”\/]\n
The index methodology<\/strong> solely finds the primary occurrence tho’. Here’s AN example with an extended string:<\/p>\n[pastacode lang=”ruby” manual=”text%20%3D%20%22Sammy%20contains%20a%20balloon%22%0Atext.index(%22a%22)%20%20%20%20%23%201″ message=”” highlight=”” provider=”manual”\/]\n
The string Sammy<\/strong> contains a balloon has four occurrences of the letter “a”. 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’s 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’ll check to examine if a string starts with a personality or substring victimization the start_with? method:<\/p>\n[pastacode lang=”ruby” manual=”text%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” message=”” highlight=”” provider=”manual”\/]\n
The start_with?<\/strong> methodology accepts multiple strings and returns true if any of them match:<\/p>\n[pastacode lang=”ruby” manual=”text%20%3D%20%22Sammy%20contains%20a%20balloon%22%0Atext.start_with%3F(%22Sammy%20the%20Shark%22%2C%20%22Sammy%22)%20%23%20true” message=”” highlight=”” provider=”manual”\/]\n
In this instance, “Sammy the Shark<\/strong>” is not found, however, “Sammy”<\/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=”ruby” manual=”text%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” message=”” highlight=”” provider=”manual”\/]\n
We’ve checked out ways that to search out text, therefore let’s 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’ll 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’s amendment the substring “has” to “had”.<\/strong><\/p>\n[pastacode lang=”ruby” manual=”balloon%20%3D%20%22Sammy%20contains%20a%20balloon%22%0Aprint%20balloon.sub(%22has%22%2C%22had%22)” message=”” highlight=”” provider=”manual”\/]\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’s use a changed string that has 2 occurrences of the word has:<\/p>\n[pastacode lang=”ruby” manual=”balloon%20%3D%20%22Sammy%20has%20a%20balloon.%20The%20balloon%20has%20a%20ribbon%22%0Aprint%20balloon.sub(%22has%22%2C%22had%22)” message=”” highlight=”” provider=”manual”\/]\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=”ruby” manual=”balloon%20%3D%20%22Sammy%20has%20a%20balloon.%20The%20balloon%20has%20a%20ribbon%22%0Aprint%20balloon.gsub(%22has%22%2C%22had%22)” message=”” highlight=”” provider=”manual”\/]\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’s demonstrate this by ever-changing “balloon” to “boomerang” in our string:<\/p>\n[pastacode lang=”ruby” manual=”text%20%3D%20%22Sammy%20has%20a%20balloon%22%0Atext.gsub(%22ballooon%22%2C%20%22boomerang%22)%0Aprint%20text” message=”” highlight=”” provider=”manual”\/]\n
Output:<\/span><\/h3>\n
Sammy has a balloon<\/code><\/p>\n
The output does not show the result we’re 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’d like, we tend to may rewrite the program like this:<\/p>\n[pastacode lang=”ruby” manual=”text%20%3D%20%22Sammy%20has%20a%20balloon%22%0Atext%20%3D%20text.sub(%22ballooon%22%2C%20%22boomerang%22)%0Aprint%20text” message=”” highlight=”” provider=”manual”\/]\n
Alternatively, you’ll use sub!<\/strong> instead, that modifies the first string. Let’s do this by doing a handful of string replacements. We’ll amendment “red balloon” to “blue boomerang”:<\/strong><\/p>\n[pastacode lang=”ruby” manual=”text%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” message=”” highlight=”” provider=”manual”\/]\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’s replace all the vowels within the string with the @ symbol:<\/strong><\/p>\n[pastacode lang=”ruby” manual=”%22Sammy%20has%20a%20red%20balloon%22.gsub%20%2F%5Baeiou%5D%2F%2C%20%22%40%22″ message=”” highlight=”” provider=”manual”\/]\n[pastacode lang=”ruby” manual=”%22S%40mmy%20h%40s%20%40%20r%40d%20b%40ll%40%40n%22″ message=”” highlight=”” provider=”manual”\/]\n
The replacement price does not need to be a string. You’ll use a hash to specify however individual characters or items ought to get replaced. Let’s replace all occurrences of the letter a with @ a<\/strong>nd every one the o characters with zeros:<\/p>\n[pastacode lang=”ruby” manual=”%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″ message=”” highlight=”” provider=”manual”\/]\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’ll 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}]}}