{"id":5962,"date":"2022-12-20T18:57:47","date_gmt":"2022-12-20T21:57:47","guid":{"rendered":"http:\/\/lode.uno\/linux-man\/index.php\/2022\/12\/20\/string-mann\/"},"modified":"2022-12-20T18:57:47","modified_gmt":"2022-12-20T21:57:47","slug":"string-mann","status":"publish","type":"post","link":"https:\/\/lode.uno\/linux-man\/2022\/12\/20\/string-mann\/","title":{"rendered":"string (mann)"},"content":{"rendered":"

string<\/h1>\n

NAME<\/a>
SYNOPSIS<\/a>
DESCRIPTION<\/a>
STRING INDICES<\/a>
EXAMPLE<\/a>
SEE ALSO<\/a>
KEYWORDS<\/a> <\/p>\n

\n

______________________________________________________________________________<\/p>\n

NAME <\/a> <\/h2>\n

string \u2212 Manipulate strings<\/p>\n

SYNOPSIS <\/a> <\/h2>\n

string<\/b> option arg<\/i> ?arg …?<\/i> ______________________________________________________________________________<\/p>\n

DESCRIPTION <\/a> <\/h2>\n

Performs one of several string operations, depending on option<\/i>. The legal option<\/i>s (which may be abbreviated) are:
string cat<\/b> ?string1<\/i>? ?string2…<\/i>?<\/p>\n

Concatenate the given string<\/i>s just like placing them directly \u2502<\/big> next to each other and return the resulting compound string. If \u2502<\/big> no string<\/i>s are present, the result is an empty string. \u2502<\/big><\/p>\n

This primitive is occasionally handier than juxtaposition of \u2502<\/big> strings when mixed quoting is wanted, or when the aim is to \u2502<\/big> return the result of a concatenation without resorting to return<\/b> \u2502<\/big> \u2212level 0<\/b>, and is more efficient than building a list of \u2502<\/big> arguments and using join<\/b> with an empty join string. \u2502<\/big><\/p>\n

string compare<\/b> ?\u2212nocase<\/b>? ?\u2212length<\/b> length<\/i>? string1 string2<\/i><\/p>\n

Perform a character-by-character comparison of strings string1<\/i> and string2<\/i>. Returns \u22121, 0, or 1, depending on whether string1<\/i> is lexicographically less than, equal to, or greater than string2<\/i>. If \u2212length<\/b> is specified, then only the first length<\/i> characters are used in the comparison. If \u2212length<\/b> is negative, it is ignored. If \u2212nocase<\/b> is specified, then the strings are compared in a case-insensitive manner.<\/p>\n

string equal<\/b> ?\u2212nocase<\/b>? ?\u2212length<\/b> length<\/i>? string1 string2<\/i><\/p>\n

Perform a character-by-character comparison of strings string1<\/i> and string2<\/i>. Returns 1 if string1<\/i> and string2<\/i> are identical, or 0 when not. If \u2212length<\/b> is specified, then only the first length<\/i> characters are used in the comparison. If \u2212length<\/b> is negative, it is ignored. If \u2212nocase<\/b> is specified, then the strings are compared in a case-insensitive manner.<\/p>\n

string first<\/b> needleString haystackString<\/i> ?startIndex<\/i>?<\/p>\n

Search haystackString<\/i> for a sequence of characters that exactly match the characters in needleString<\/i>. If found, return the index of the first character in the first such match within haystackString<\/i>. If not found, return \u22121. If startIndex<\/i> is specified (in any of the forms described in STRING INDICES<\/b>), then the search is constrained to start with the character in haystackString<\/i> specified by the index. For example,<\/p>\n

string first a 0a23456789abcdef 5<\/b><\/p>\n

will return 10<\/b>, but<\/p>\n

string first a 0123456789abcdef 11<\/b><\/p>\n

will return \u22121<\/b>.<\/p>\n

string index<\/b> string charIndex<\/i><\/p>\n

Returns the charIndex<\/i>\u2019th character of the string<\/i> argument. A charIndex<\/i> of 0 corresponds to the first character of the string. charIndex<\/i> may be specified as described in the STRING INDICES<\/b> section.<\/p>\n

If charIndex<\/i> is less than 0 or greater than or equal to the length of the string then this command returns an empty string.<\/p>\n

string is<\/b> class<\/i> ?\u2212strict<\/b>? ?\u2212failindex<\/b> varname<\/i>? string<\/i><\/p>\n

Returns 1 if string<\/i> is a valid member of the specified character class, otherwise returns 0. If \u2212strict<\/b> is specified, then an empty string returns 0, otherwise an empty string will return 1 on any class. If \u2212failindex<\/b> is specified, then if the function returns 0, the index in the string where the class was no longer valid will be stored in the variable named varname<\/i>. The varname<\/i> will not be set if string is<\/b> returns 1. The following character classes are recognized (the class name can be abbreviated):<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
<\/td>\n\n

alnum<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any Unicode alphabet or digit character.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

alpha<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any Unicode alphabet character.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

ascii<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any character with a value less than u0080 (those that are in the 7\u2212bit ascii range).<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

boolean<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any of the forms allowed to Tcl_GetBoolean<\/b>.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

control<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any Unicode control character.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

digit<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any Unicode digit character. Note that this includes characters outside of the [0\u22129] range.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

double<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any of the forms allowed to Tcl_GetDoubleFromObj<\/b>.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

entier<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any of the valid string formats for an integer value \u2502<\/big> of arbitrary size in Tcl, with optional surrounding \u2502<\/big> whitespace. The formats accepted are exactly those \u2502<\/big> accepted by the C routine Tcl_GetBignumFromObj<\/b>.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

false<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any of the forms allowed to Tcl_GetBoolean<\/b> where the value is false.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

graph<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any Unicode printing character, except space.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

integer<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any of the valid string formats for a 32-bit integer value in Tcl, with optional surrounding whitespace. In case of overflow in the value, 0 is returned and the varname<\/i> will contain \u22121.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

list<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any proper list structure, with optional surrounding whitespace. In case of improper list structure, 0 is returned and the varname<\/i> will contain the index of the \u201celement\u201d where the list parsing fails, or \u22121 if this cannot be determined.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

lower<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any Unicode lower case alphabet character.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

print<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any Unicode printing character, including space.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

punct<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any Unicode punctuation character.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

space<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any Unicode whitespace character, mongolian vowel separator (U+180e), zero width space (U+200b), word joiner (U+2060) or zero width no-break space (U+feff) (=BOM).<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

true<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any of the forms allowed to Tcl_GetBoolean<\/b> where the value is true.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

upper<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any upper case alphabet character in the Unicode character set.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

wideinteger<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any of the valid forms for a wide integer in Tcl, with optional surrounding whitespace. In case of overflow in the value, 0 is returned and the varname<\/i> will contain \u22121.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

wordchar<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any Unicode word character. That is any alphanumeric character, and any Unicode connector punctuation characters (e.g. underscore).<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

xdigit<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Any hexadecimal digit character ([0\u22129A\u2212Fa\u2212f]).<\/p>\n<\/td>\n<\/tr>\n<\/table>\n

In the case of boolean<\/b>, true<\/b> and false<\/b>, if the function will return 0, then the varname<\/i> will always be set to 0, due to the varied nature of a valid boolean value.<\/p>\n

string last<\/b> needleString haystackString<\/i> ?lastIndex<\/i>?<\/p>\n

Search haystackString<\/i> for a sequence of characters that exactly match the characters in needleString<\/i>. If found, return the index of the first character in the last such match within haystackString<\/i>. If there is no match, then return \u22121. If lastIndex<\/i> is specified (in any of the forms described in STRING INDICES<\/b>), then only the characters in haystackString<\/i> at or before the specified lastIndex<\/i> will be considered by the search. For example,<\/p>\n

string last a 0a23456789abcdef 15<\/b><\/p>\n

will return 10<\/b>, but<\/p>\n

string last a 0a23456789abcdef 9<\/b><\/p>\n

will return 1<\/b>.<\/p>\n

string length<\/b> string<\/i><\/p>\n

Returns a decimal string giving the number of characters in string<\/i>. Note that this is not necessarily the same as the number of bytes used to store the string. If the value is a byte array value (such as those returned from reading a binary encoded channel), then this will return the actual byte length of the value.<\/p>\n

string map<\/b> ?\u2212nocase<\/b>? mapping string<\/i><\/p>\n

Replaces substrings in string<\/i> based on the key-value pairs in mapping<\/i>. mapping<\/i> is a list of key value key value …<\/i> as in the form returned by array get<\/b>. Each instance of a key in the string will be replaced with its corresponding value. If \u2212nocase<\/b> is specified, then matching is done without regard to case differences. Both key<\/i> and value<\/i> may be multiple characters. Replacement is done in an ordered manner, so the key appearing first in the list will be checked first, and so on. string<\/i> is only iterated over once, so earlier key replacements will have no affect for later key matches. For example,<\/p>\n

string map {abc 1 ab 2 a 3 1 0} 1abcaababcabababc<\/b><\/p>\n

will return the string 01321221<\/b>.<\/p>\n

Note that if an earlier key<\/i> is a prefix of a later one, it will completely mask the later one. So if the previous example is reordered like this,<\/p>\n

string map {1 0 ab 2 a 3 abc 1} 1abcaababcabababc<\/b><\/p>\n

it will return the string 02c322c222c<\/b>.<\/p>\n

string match<\/b> ?\u2212nocase<\/b>? pattern string<\/i><\/p>\n

See if pattern<\/i> matches string<\/i>; return 1 if it does, 0 if it does not. If \u2212nocase<\/b> is specified, then the pattern attempts to match against the string in a case insensitive manner. For the two strings to match, their contents must be identical except that the following special sequences may appear in pattern<\/i>:<\/p>\n\n\n\n\n\n
<\/td>\n\n

*<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Matches any sequence of characters in string<\/i>, including a null string.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

?<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Matches any single character in string<\/i>.<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

[<\/b>chars<\/i>]<\/b><\/p>\n<\/td>\n

<\/td>\n\n

Matches any character in the set given by chars<\/i>. If a sequence of the form x<\/i>\u2212<\/b>y<\/i> appears in chars<\/i>, then any character between x<\/i> and y<\/i>, inclusive, will match. When used with \u2212nocase<\/b>, the end points of the range are converted to lower case first. Whereas {[A\u2212z]} matches \u201c_\u201d when matching case-sensitively (since \u201c_\u201d falls between the \u201cZ\u201d and \u201ca\u201d), with \u2212nocase<\/b> this is considered like {[A\u2212Za\u2212z]} (and probably what was meant in the first place).<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

<\/b>x<\/i><\/p>\n<\/td>\n

<\/td>\n\n

Matches the single character x<\/i>. This provides a way of avoiding the special interpretation of the characters *?[]<\/b> in pattern<\/i>.<\/p>\n<\/td>\n<\/tr>\n<\/table>\n

string range<\/b> string first last<\/i><\/p>\n

Returns a range of consecutive characters from string<\/i>, starting with the character whose index is first<\/i> and ending with the character whose index is last<\/i>. An index of 0 refers to the first character of the string. first<\/i> and last<\/i> may be specified as for the index<\/b> method. If first<\/i> is less than zero then it is treated as if it were zero, and if last<\/i> is greater than or equal to the length of the string then it is treated as if it were end<\/b>. If first<\/i> is greater than last<\/i> then an empty string is returned.<\/p>\n

string repeat<\/b> string count<\/i><\/p>\n

Returns string<\/i> repeated count<\/i> number of times.<\/p>\n

string replace<\/b> string first last<\/i> ?newstring<\/i>?<\/p>\n

Removes a range of consecutive characters from string<\/i>, starting with the character whose index is first<\/i> and ending with the character whose index is last<\/i>. An index of 0 refers to the first character of the string. First<\/i> and last<\/i> may be specified as for the index<\/b> method. If newstring<\/i> is specified, then it is placed in the removed character range. If first<\/i> is less than zero then it is treated as if it were zero, and if last<\/i> is greater than or equal to the length of the string then it is treated as if it were end<\/b>. If first<\/i> is greater than last<\/i> or the length of the initial string, or last<\/i> is less than 0, then the initial string is returned untouched.<\/p>\n

string reverse<\/b> string<\/i><\/p>\n

Returns a string that is the same length as string<\/i> but with its characters in the reverse order.<\/p>\n

string tolower<\/b> string<\/i> ?first<\/i>? ?last<\/i>?<\/p>\n

Returns a value equal to string<\/i> except that all upper (or title) case letters have been converted to lower case. If first<\/i> is specified, it refers to the first char index in the string to start modifying. If last<\/i> is specified, it refers to the char index in the string to stop at (inclusive). first<\/i> and last<\/i> may be specified using the forms described in STRING INDICES<\/b>.<\/p>\n

string totitle<\/b> string<\/i> ?first<\/i>? ?last<\/i>?<\/p>\n

Returns a value equal to string<\/i> except that the first character in string<\/i> is converted to its Unicode title case variant (or upper case if there is no title case variant) and the rest of the string is converted to lower case. If first<\/i> is specified, it refers to the first char index in the string to start modifying. If last<\/i> is specified, it refers to the char index in the string to stop at (inclusive). first<\/i> and last<\/i> may be specified using the forms described in STRING INDICES<\/b>.<\/p>\n

string toupper<\/b> string<\/i> ?first<\/i>? ?last<\/i>?<\/p>\n

Returns a value equal to string<\/i> except that all lower (or title) case letters have been converted to upper case. If first<\/i> is specified, it refers to the first char index in the string to start modifying. If last<\/i> is specified, it refers to the char index in the string to stop at (inclusive). first<\/i> and last<\/i> may be specified using the forms described in STRING INDICES<\/b>.<\/p>\n

string trim<\/b> string<\/i> ?chars<\/i>?<\/p>\n

Returns a value equal to string<\/i> except that any leading or trailing characters present in the string given by chars<\/i> are removed. If chars<\/i> is not specified then white space is removed (any character for which string is space<\/b> returns 1, and “\u0000”).<\/p>\n

string trimleft<\/b> string<\/i> ?chars<\/i>?<\/p>\n

Returns a value equal to string<\/i> except that any leading characters present in the string given by chars<\/i> are removed. If chars<\/i> is not specified then white space is removed (any character for which string is space<\/b> returns 1, and “\u0000”).<\/p>\n

string trimright<\/b> string<\/i> ?chars<\/i>?<\/p>\n

Returns a value equal to string<\/i> except that any trailing characters present in the string given by chars<\/i> are removed. If chars<\/i> is not specified then white space is removed (any character for which string is space<\/b> returns 1, and “\u0000”).<\/p>\n

OBSOLETE SUBCOMMANDS<\/b>
These subcommands are currently supported, but are likely to go away in a future release as their functionality is either virtually never used or highly misleading.
string bytelength<\/b> string<\/i><\/p>\n

Returns a decimal string giving the number of bytes used to represent string<\/i> in memory when encoded as Tcl\u2019s internal modified UTF\u22128; Tcl may use other encodings for string<\/i> as well, and does not guarantee to only use a single encoding for a particular string<\/i>. Because UTF\u22128 uses a variable number of bytes to represent Unicode characters, the byte length will not be the same as the character length in general. The cases where a script cares about the byte length are rare.<\/p>\n

In almost all cases, you should use the string length<\/b> operation (including determining the length of a Tcl byte array value). Refer to the Tcl_NumUtfChars<\/b> manual entry for more details on the UTF\u22128 representation.<\/p>\n

Formally, the string bytelength<\/b> operation returns the content of the length<\/i> field of the Tcl_Obj<\/b> structure, after calling Tcl_GetString<\/b> to ensure that the bytes<\/i> field is populated. This is highly unlikely to be useful to Tcl scripts, as Tcl\u2019s internal encoding is not strict UTF\u22128, but rather a modified CESU\u22128 with a denormalized NUL (identical to that used in a number of places by Java\u2019s serialization mechanism) to enable basic processing with non-Unicode-aware C functions. As this representation should only ever be used by Tcl\u2019s implementation, the number of bytes used to store the representation is of very low value (except to C extension code, which has direct access for the purpose of memory management, etc.)<\/p>\n

Compatibility note:<\/i> it is likely that this subcommand will be withdrawn in a future version of Tcl. It is better to use the encoding convertto<\/b> command to convert a string to a known encoding and then apply string length<\/b> to that.<\/p>\n

string length<\/b> [encoding convertto utf-8 $theString]<\/p>\n

string wordend<\/b> string charIndex<\/i><\/p>\n

Returns the index of the character just after the last one in the word containing character charIndex<\/i> of string<\/i>. charIndex<\/i> may be specified using the forms in STRING INDICES<\/b>. A word is considered to be any contiguous range of alphanumeric (Unicode letters or decimal digits) or underscore (Unicode connector punctuation) characters, or any single character other than these.<\/p>\n

string wordstart<\/b> string charIndex<\/i><\/p>\n

Returns the index of the first character in the word containing character charIndex<\/i> of string<\/i>. charIndex<\/i> may be specified using the forms in STRING INDICES<\/b>. A word is considered to be any contiguous range of alphanumeric (Unicode letters or decimal digits) or underscore (Unicode connector punctuation) characters, or any single character other than these.<\/p>\n

STRING INDICES <\/a> <\/h2>\n

When referring to indices into a string (e.g., for string index<\/b> or string range<\/b>) the following formats are supported:<\/p>\n\n\n\n\n\n\n\n
<\/td>\n\n

integer<\/i><\/p>\n<\/td>\n

<\/td>\n\n

For any index value that passes string is integer \u2212strict<\/b>, the char specified at this integral index (e.g., 2<\/b> would refer to the \u201cc\u201d in \u201cabcd\u201d).<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

end<\/b><\/p>\n<\/td>\n

<\/td>\n\n

The last char of the string (e.g., end<\/b> would refer to the \u201cd\u201d in \u201cabcd\u201d).<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

end\u2212<\/b>N<\/i><\/p>\n<\/td>\n

<\/td>\n\n

The last char of the string minus the specified integer offset N<\/i> (e.g., \u201cend\u22121<\/b>\u201d would refer to the \u201cc\u201d in \u201cabcd\u201d).<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

end+<\/b>N<\/i><\/p>\n<\/td>\n

<\/td>\n\n

The last char of the string plus the specified integer offset N<\/i> (e.g., \u201cend+\u22121<\/b>\u201d would refer to the \u201cc\u201d in \u201cabcd\u201d).<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

M<\/i>+<\/b>N<\/i><\/p>\n<\/td>\n

<\/td>\n\n

The char specified at the integral index that is the sum of integer values M<\/i> and N<\/i> (e.g., \u201c1+1<\/b>\u201d would refer to the \u201cc\u201d in \u201cabcd\u201d).<\/p>\n<\/td>\n<\/tr>\n

<\/td>\n\n

M<\/i>\u2212<\/b>N<\/i><\/p>\n<\/td>\n

<\/td>\n\n

The char specified at the integral index that is the difference of integer values M<\/i> and N<\/i> (e.g., \u201c2\u22121<\/b>\u201d would refer to the \u201cb\u201d in \u201cabcd\u201d).<\/p>\n<\/td>\n<\/tr>\n<\/table>\n

In the specifications above, the integer value M<\/i> contains no trailing whitespace and the integer value N<\/i> contains no leading whitespace.<\/p>\n

EXAMPLE <\/a> <\/h2>\n

Test if the string in the variable string<\/i> is a proper non-empty prefix of the string foobar<\/b>.<\/p>\n

set length [string length<\/b> $string]
if {$length == 0} {
set isPrefix 0
} else {
set isPrefix [string equal<\/b> \u2212length $length $string “foobar”]
}<\/p>\n

SEE ALSO <\/a> <\/h2>\n

expr(n), list(n)<\/p>\n

KEYWORDS <\/a> <\/h2>\n

case conversion, compare, index, match, pattern, string, word, equal, ctype, character, reverse<\/p>\n

\n","protected":false},"excerpt":{"rendered":"

string \u2212 Manipulate strings <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3783,1],"tags":[2635,2656],"class_list":["post-5962","post","type-post","status-publish","format-standard","hentry","category-n-comandos-tcl-tk","category-sin-categoria","tag-mann","tag-string"],"gutentor_comment":0,"_links":{"self":[{"href":"https:\/\/lode.uno\/linux-man\/wp-json\/wp\/v2\/posts\/5962","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/lode.uno\/linux-man\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/lode.uno\/linux-man\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/lode.uno\/linux-man\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/lode.uno\/linux-man\/wp-json\/wp\/v2\/comments?post=5962"}],"version-history":[{"count":0,"href":"https:\/\/lode.uno\/linux-man\/wp-json\/wp\/v2\/posts\/5962\/revisions"}],"wp:attachment":[{"href":"https:\/\/lode.uno\/linux-man\/wp-json\/wp\/v2\/media?parent=5962"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/lode.uno\/linux-man\/wp-json\/wp\/v2\/categories?post=5962"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/lode.uno\/linux-man\/wp-json\/wp\/v2\/tags?post=5962"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}