{"id":18613,"date":"2026-09-22T08:08:23","date_gmt":"2026-09-22T08:08:23","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=18613"},"modified":"2026-09-22T08:08:23","modified_gmt":"2026-09-22T08:08:23","slug":"lpi-101-500-practice-test-questions-and-exam-dumps-part-4-q61-80","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/lpi-101-500-practice-test-questions-and-exam-dumps-part-4-q61-80\/","title":{"rendered":"LPI 101-500 Practice Test Questions and Exam Dumps Part 4 Q61-80"},"content":{"rendered":"

View Full<\/b> LPI 101-500<\/b> Exam Dumps<\/b><\/a> and Practice Test Dumps<\/b><\/p>\n

 <\/p>\n

Question: 61. Which command is commonly used to view a text file one screen at a time with support for scrolling backward and forward?<\/b><\/p>\n

    \n
  1. <\/b> less<\/span>
    \n<\/span>2.<\/b> cat<\/span>
    \n<\/span>3.<\/b> head<\/span>
    \n<\/span>4.<\/b> echo<\/span><\/li>\n<\/ol>\n

    Correct Answer:<\/b> 1. <\/span>less<\/span><\/p>\n

    Explanation:<\/b><\/p>\n

    The <\/span>less<\/span> command is commonly used to view text files interactively, one screen at a time. Unlike <\/span>cat<\/span>, which normally sends an entire file directly to standard output, <\/span>less<\/span> allows the user to scroll forward and backward through the content. It is especially useful for examining large log files or configuration files without displaying everything at once. Users can search within the displayed content and navigate through the file using keyboard commands. The <\/span>head<\/span> command displays the beginning of a file, while <\/span>echo<\/span> prints specified text. Therefore, <\/span>less<\/span> is the appropriate command for interactive text-file viewing.<\/span><\/p>\n

    Question: 62. Which command sorts lines of text alphabetically by default?<\/b><\/p>\n

      \n
    1. <\/b> order<\/span>
      \n<\/span>2.<\/b> sort<\/span>
      \n<\/span>3.<\/b> arrange<\/span>
      \n<\/span>4.<\/b> rank<\/span><\/li>\n<\/ol>\n

      Correct Answer:<\/b> 2. <\/span>sort<\/span><\/p>\n

      Explanation:<\/b><\/p>\n

      The <\/span>sort<\/span> command arranges lines of text according to specified sorting rules. By default, it performs a lexicographic sort, which generally means arranging lines according to their character order. It can also sort numerically, reverse the order, or use particular fields as sorting keys. For example, <\/span>sort names.txt<\/span> produces sorted output from the lines in the file. The other commands listed are not standard Linux utilities for performing general text sorting. <\/span>sort<\/span> is frequently combined with commands such as <\/span>uniq<\/span> when processing and analyzing text data. Understanding basic text-processing commands is an important Linux administration skill.<\/span><\/p>\n

      Question: 63. Which command removes adjacent duplicate lines from sorted or appropriately grouped input?<\/b><\/p>\n

        \n
      1. <\/b> duplicate<\/span>
        \n<\/span>2.<\/b> unique<\/span>
        \n<\/span>3.<\/b> uniq<\/span>
        \n<\/span>4.<\/b> dedupe<\/span><\/li>\n<\/ol>\n

        Correct Answer:<\/b> 3. <\/span>uniq<\/span><\/p>\n

        Explanation:<\/b><\/p>\n

        The <\/span>uniq<\/span> command is used to report or remove repeated adjacent lines from input. A common pattern is to combine <\/span>sort<\/span> and <\/span>uniq<\/span>, such as <\/span>sort names.txt | uniq<\/span>, because <\/span>uniq<\/span> only identifies consecutive duplicate lines rather than searching the entire input for duplicates regardless of position. It also provides options for counting occurrences and displaying only repeated or unique lines. The commands <\/span>duplicate<\/span>, <\/span>unique<\/span>, and <\/span>dedupe<\/span> are not standard Linux utilities for this purpose. Understanding the relationship between <\/span>sort<\/span> and <\/span>uniq<\/span> is useful when processing lists, logs, and other structured text data.<\/span><\/p>\n

        Question: 64. Which command can extract selected characters or fields from each line of text?<\/b><\/p>\n

          \n
        1. <\/b> cut<\/span>
          \n<\/span>2.<\/b> slice<\/span>
          \n<\/span>3.<\/b> field<\/span>
          \n<\/span>4.<\/b> extract<\/span><\/li>\n<\/ol>\n

          Correct Answer:<\/b> 1. <\/span>cut<\/span><\/p>\n

          Explanation:<\/b><\/p>\n

          The <\/span>cut<\/span> command extracts selected portions of each line of input. It can work with character positions, byte positions, or fields separated by a specified delimiter. For example, <\/span>cut -d: -f1 \/etc\/passwd<\/span> can extract the first field from each colon-separated line. This makes <\/span>cut<\/span> useful for processing structured text and command output. The commands <\/span>slice<\/span>, <\/span>field<\/span>, and <\/span>extract<\/span> are not standard general-purpose Linux replacements for <\/span>cut<\/span>. It is important to understand the difference between selecting character ranges and selecting delimiter-separated fields when using this command.<\/span><\/p>\n

          Question: 65. Which command can translate or replace individual characters in a stream of text?<\/b><\/p>\n

            \n
          1. <\/b> replace<\/span>
            \n<\/span>2.<\/b> convert<\/span>
            \n<\/span>3.<\/b> tr<\/span>
            \n<\/span>4.<\/b> change<\/span><\/li>\n<\/ol>\n

            Correct Answer:<\/b> 3. <\/span>tr<\/span><\/p>\n

            Explanation:<\/b><\/p>\n

            The <\/span>tr<\/span> command translates, replaces, or deletes characters from standard input and writes the result to standard output. For example, <\/span>tr ‘a-z’ ‘A-Z’<\/span> can convert lowercase letters to uppercase letters. It can also remove selected characters using appropriate options. Because <\/span>tr<\/span> normally operates on standard input rather than directly modifying a file, it is commonly used in pipelines. The commands <\/span>replace<\/span>, <\/span>convert<\/span>, and <\/span>change<\/span> are not standard Linux utilities serving this exact purpose. <\/span>tr<\/span> is particularly useful for simple character-level transformations during shell scripting and text processing.<\/span><\/p>\n

            Question: 66. Which command displays input on standard output while also writing it to one or more files?<\/b><\/p>\n

              \n
            1. <\/b> tee<\/span>
              \n<\/span>2.<\/b> split<\/span>
              \n<\/span>3.<\/b> copyout<\/span>
              \n<\/span>4.<\/b> duplicate<\/span><\/li>\n<\/ol>\n

              Correct Answer:<\/b> 1. <\/span>tee<\/span><\/p>\n

              Explanation:<\/b><\/p>\n

              The <\/span>tee<\/span> command reads data from standard input and writes it both to standard output and to one or more files. This is useful when a user wants to save command output while still seeing it in the terminal. For example, <\/span>command | tee output.txt<\/span> displays the command’s output and simultaneously writes it to <\/span>output.txt<\/span>. With the appropriate option, <\/span>tee<\/span> can append rather than overwrite a file. The commands <\/span>split<\/span>, <\/span>copyout<\/span>, and <\/span>duplicate<\/span> do not provide this standard pipeline behavior. <\/span>tee<\/span> is therefore an important utility for shell pipelines and troubleshooting.<\/span><\/p>\n

              Question: 67. Which command is commonly used to execute a command once for each item received from standard input?<\/b><\/p>\n

                \n
              1. <\/b> each<\/span>
                \n<\/span>2.<\/b> apply<\/span>
                \n<\/span>3.<\/b> xargs<\/span>
                \n<\/span>4.<\/b> foreach<\/span><\/li>\n<\/ol>\n

                Correct Answer:<\/b> 3. <\/span>xargs<\/span><\/p>\n

                Explanation:<\/b><\/p>\n

                The <\/span>xargs<\/span> command builds and executes commands using items supplied through standard input. It is particularly useful when the output of one command needs to become arguments for another command. For example, a list of filenames can be passed to another utility through a pipeline using <\/span>xargs<\/span>. Depending on its options and the input, <\/span>xargs<\/span> can execute the target command multiple times, grouping arguments efficiently. The commands <\/span>each<\/span>, <\/span>apply<\/span>, and <\/span>foreach<\/span> are not standard Linux utilities providing this functionality. Care should be taken with filenames containing spaces or special characters, where appropriate quoting and null-delimited input may be needed.<\/span><\/p>\n

                Question: 68. Which shell syntax performs command substitution and replaces the command with its output?<\/b><\/p>\n

                  \n
                1. <\/b> ${command}<\/span>
                  \n<\/span>2.<\/b> $(command)<\/span>
                  \n<\/span>3.<\/b> <command><\/span>
                  \n<\/span>4.<\/b> [command]<\/span><\/li>\n<\/ol>\n

                  Correct Answer:<\/b> 2. <\/span>$(command)<\/span><\/p>\n

                  Explanation:<\/b><\/p>\n

                  The <\/span>$(command)<\/span> syntax performs command substitution in common Unix shells. The shell executes the command inside the parentheses and substitutes its standard output into the surrounding command line. For example, <\/span>echo “Today is $(date)”<\/span> executes <\/span>date<\/span> and places its output into the string before <\/span>echo<\/span> runs. Command substitution is widely used in shell scripts and interactive commands when the result of one command needs to become part of another command. Although older shell syntax using backticks can also perform command substitution, <\/span>$(…)<\/span> is generally clearer and easier to nest.<\/span><\/p>\n

                  Question: 69. In a typical POSIX shell, which type of quotes prevents variable expansion and command substitution inside the quoted text?<\/b><\/p>\n

                    \n
                  1. <\/b> Double quotes <\/span>” “<\/span>
                    \n<\/span>2.<\/b> Parentheses <\/span>( )<\/span>
                    \n<\/span>3.<\/b> Brackets <\/span>[ ]<\/span>
                    \n<\/span>4.<\/b> Single quotes <\/span>‘ ‘<\/span><\/li>\n<\/ol>\n

                    Correct Answer:<\/b> 4. Single quotes <\/span>‘ ‘<\/span><\/p>\n

                    Explanation:<\/b><\/p>\n

                    Single quotes preserve the literal meaning of almost all characters inside them in a POSIX shell. Variable references such as <\/span>$HOME<\/span> and command substitutions such as <\/span>$(date)<\/span> are not expanded when enclosed in single quotes. Double quotes provide protection from word splitting and pathname expansion but still allow variable expansion and command substitution. This distinction is important when constructing shell commands and scripts that contain special characters or literal dollar signs. Parentheses and brackets have other shell meanings and do not provide the same general quoting behavior. Therefore, single quotes are the correct answer for preventing these expansions.<\/span><\/p>\n

                    Question: 70. Which shell character is commonly used to escape the special meaning of the next character?<\/b><\/p>\n

                      \n
                    1. <\/b> #<\/span>
                      \n<\/span>2.<\/b> &<\/span>
                      \n<\/span>3.<\/b> \\<\/span>
                      \n<\/span>4.<\/b> @<\/span><\/li>\n<\/ol>\n

                      Correct Answer:<\/b> 3. <\/span>\\<\/span><\/p>\n

                      Explanation:<\/b><\/p>\n

                      The backslash character, <\/span>\\<\/span>, is commonly used by the shell to escape the special meaning of the character that follows it. For example, <\/span>echo \\$HOME<\/span> can display the literal text <\/span>$HOME<\/span> rather than expanding the variable. Similarly, a backslash can be used to include spaces or other special characters in appropriate shell contexts. The <\/span>#<\/span> character commonly begins comments in shell scripts, <\/span>&<\/span> can be used for background execution, and <\/span>@<\/span> has other contextual uses but is not the standard general-purpose escape character. Understanding escaping is essential when working with shell metacharacters and filenames.<\/span><\/p>\n

                      Question: 71. Which path represents an absolute path in Linux?<\/b><\/p>\n

                        \n
                      1. <\/b> documents\/report.txt<\/span>
                        \n<\/span>2.<\/b> ..\/report.txt<\/span>
                        \n<\/span>3.<\/b> .\/report.txt<\/span>
                        \n<\/span>4.<\/b> \/home\/user\/report.txt<\/span><\/li>\n<\/ol>\n

                        Correct Answer:<\/b> 4. <\/span>\/home\/user\/report.txt<\/span><\/p>\n

                        Explanation:<\/b><\/p>\n

                        An absolute path begins at the root directory, represented by <\/span>\/<\/span>, and identifies a location independently of the user’s current working directory. <\/span>\/home\/user\/report.txt<\/span> is therefore an absolute path because it starts from the root and provides the complete path to the file. In contrast, <\/span>documents\/report.txt<\/span>, <\/span>..\/report.txt<\/span>, and <\/span>.\/report.txt<\/span> are relative paths whose meanings depend on the current working directory. Understanding the difference is important when writing shell commands and scripts because absolute paths provide a fixed reference while relative paths depend on where the command is executed.<\/span><\/p>\n

                        Question: 72. Which command creates a hard link to an existing file?<\/b><\/p>\n

                          \n
                        1. <\/b> ln<\/span>
                          \n<\/span>2.<\/b> linkfile<\/span>
                          \n<\/span>3.<\/b> ln -s<\/span>
                          \n<\/span>4.<\/b> hardlink<\/span><\/li>\n<\/ol>\n

                          Correct Answer:<\/b> 1. <\/span>ln<\/span><\/p>\n

                          Explanation:<\/b><\/p>\n

                          The <\/span>ln<\/span> command creates links between filesystem directory entries and files. When used without the <\/span>-s<\/span> option, <\/span>ln<\/span> normally creates a hard link. A hard link refers to the same underlying inode as the original file, so both directory entries refer to the same file data. By contrast, <\/span>ln -s<\/span> creates a symbolic link, which stores a path referring to another file or directory. The commands <\/span>linkfile<\/span> and <\/span>hardlink<\/span> are not the standard general-purpose Linux commands for creating hard links. Hard links generally cannot cross filesystem boundaries and have restrictions concerning directories.<\/span><\/p>\n

                          Question: 73. Which command displays detailed metadata about a file, including information such as its inode, permissions, size, and timestamps?<\/b><\/p>\n

                            \n
                          1. <\/b> metadata<\/span>
                            \n<\/span>2.<\/b> stat<\/span>
                            \n<\/span>3.<\/b> fileinfo<\/span>
                            \n<\/span>4.<\/b> details<\/span><\/li>\n<\/ol>\n

                            Correct Answer:<\/b> 2. <\/span>stat<\/span><\/p>\n

                            Explanation:<\/b><\/p>\n

                            The <\/span>stat<\/span> command displays detailed information about a file or filesystem object. Its output can include the file size, inode number, permissions, ownership, timestamps, and file type. This makes <\/span>stat<\/span> useful when ordinary directory listings do not provide enough information for troubleshooting or administration. The <\/span>file<\/span> command can identify the general type of a file, but it does not provide the same detailed metadata. <\/span>metadata<\/span>, <\/span>fileinfo<\/span>, and <\/span>details<\/span> are not the standard Linux command represented here. Therefore, <\/span>stat<\/span> is the correct utility for examining detailed filesystem metadata.<\/span><\/p>\n

                            Question: 74. Which command extracts the final component of a pathname?<\/b><\/p>\n

                              \n
                            1. <\/b> pathpart<\/span>
                              \n<\/span>2.<\/b> dirname<\/span>
                              \n<\/span>3.<\/b> basename<\/span>
                              \n<\/span>4.<\/b> lastpath<\/span><\/li>\n<\/ol>\n

                              Correct Answer:<\/b> 3. <\/span>basename<\/span><\/p>\n

                              Explanation:<\/b><\/p>\n

                              The <\/span>basename<\/span> command extracts the final component of a pathname. For example, <\/span>basename \/home\/user\/report.txt<\/span> returns <\/span>report.txt<\/span>. This is useful in shell scripts when a script needs to separate a filename from the directory portion of a path. The complementary <\/span>dirname<\/span> command extracts the directory portion instead. The commands <\/span>pathpart<\/span> and <\/span>lastpath<\/span> are not standard Linux utilities for this purpose. Understanding <\/span>basename<\/span> and <\/span>dirname<\/span> is useful for manipulating paths without manually processing strings in shell scripts.<\/span><\/p>\n

                              Question: 75. Which command outputs a specified string or the value of a variable to standard output?<\/b><\/p>\n

                                \n
                              1. <\/b> echo<\/span>
                                \n<\/span>2.<\/b> display<\/span>
                                \n<\/span>3.<\/b> printtext<\/span>
                                \n<\/span>4.<\/b> show<\/span><\/li>\n<\/ol>\n

                                Correct Answer:<\/b> 1. <\/span>echo<\/span><\/p>\n

                                Explanation:<\/b><\/p>\n

                                The <\/span>echo<\/span> command writes specified text or expanded variable values to standard output. It is commonly used interactively and within shell scripts to display messages or simple values. For example, <\/span>echo “$HOME”<\/span> displays the value of the <\/span>HOME<\/span> environment variable. Shell implementations may provide <\/span>echo<\/span> as a builtin, and its behavior for certain escape sequences can vary between implementations, which is one reason <\/span>printf<\/span> is often preferred for portable formatted output. Nevertheless, <\/span>echo<\/span> remains a fundamental command for basic shell output. The other listed commands are not standard general-purpose replacements for <\/span>echo<\/span>.<\/span><\/p>\n

                                Question: 76. Which command is generally preferred for portable formatted output in shell scripts?<\/b><\/p>\n

                                  \n
                                1. <\/b> display<\/span>
                                  \n<\/span>2.<\/b> printf<\/span>
                                  \n<\/span>3.<\/b> format<\/span>
                                  \n<\/span>4.<\/b> echo<\/span><\/li>\n<\/ol>\n

                                  Correct Answer:<\/b> 2. <\/span>printf<\/span><\/p>\n

                                  Explanation:<\/b><\/p>\n

                                  The <\/span>printf<\/span> command provides formatted output and is generally preferred over <\/span>echo<\/span> when predictable behavior is important in shell scripts. It supports format specifications such as <\/span>%s<\/span>, <\/span>%d<\/span>, and <\/span>%f<\/span>, allowing scripts to control how values are displayed. For example, <\/span>printf “User: %s\\n” “$USER”<\/span> produces predictable formatted output. Although <\/span>echo<\/span> is convenient for simple messages, its handling of certain options and escape sequences can vary among implementations. <\/span>printf<\/span> follows well-defined formatting behavior and is therefore particularly useful in portable shell scripting. The other choices are not standard replacements for formatted shell output.<\/span><\/p>\n

                                  Question: 77. Which command makes a shell variable available to programs started from that shell?<\/b><\/p>\n

                                    \n
                                  1. <\/b> export<\/span>
                                    \n<\/span>2.<\/b> share<\/span>
                                    \n<\/span>3.<\/b> envset<\/span>
                                    \n<\/span>4.<\/b> publish<\/span><\/li>\n<\/ol>\n

                                    Correct Answer:<\/b> 1. <\/span>export<\/span><\/p>\n

                                    Explanation:<\/b><\/p>\n

                                    The <\/span>export<\/span> command marks a shell variable so that it becomes part of the environment inherited by subsequently executed child processes. For example, <\/span>export EDITOR=vim<\/span> makes the <\/span>EDITOR<\/span> variable available to programs launched from that shell. A variable that has been assigned without being exported normally remains a shell variable and is not automatically inherited by child processes. The commands <\/span>share<\/span>, <\/span>envset<\/span>, and <\/span>publish<\/span> are not standard shell commands for exporting variables. Understanding the distinction between shell variables and environment variables is important when configuring programs and writing shell scripts.<\/span><\/p>\n

                                    Question: 78. Which command can display the environment variables available to a command or shell?<\/b><\/p>\n

                                      \n
                                    1. <\/b> vars<\/span>
                                      \n<\/span>2.<\/b> environment<\/span>
                                      \n<\/span>3.<\/b> env<\/span>
                                      \n<\/span>4.<\/b> showenv<\/span><\/li>\n<\/ol>\n

                                      Correct Answer:<\/b> 3. <\/span>env<\/span><\/p>\n

                                      Explanation:<\/b><\/p>\n

                                      The <\/span>env<\/span> command can display the environment variables associated with the current execution environment. It can also be used to run a command with a modified environment. For example, running <\/span>env<\/span> without arguments generally displays environment variable assignments such as <\/span>HOME<\/span>, <\/span>PATH<\/span>, and <\/span>USER<\/span>. Environment variables differ from ordinary shell variables because exported variables are inherited by child processes. The commands <\/span>vars<\/span>, <\/span>environment<\/span>, and <\/span>showenv<\/span> are not the standard Linux utility represented here. Therefore, <\/span>env<\/span> is the correct command for viewing or manipulating the execution environment.<\/span><\/p>\n

                                      Question: 79. Which shell variable contains the exit status of the most recently executed foreground command?<\/b><\/p>\n

                                        \n
                                      1. <\/b> $STATUS<\/span>
                                        \n<\/span>2.<\/b> $EXIT<\/span>
                                        \n<\/span>3.<\/b> $RESULT<\/span>
                                        \n<\/span>4.<\/b> $?<\/span><\/li>\n<\/ol>\n

                                        Correct Answer:<\/b> 4. <\/span>$?<\/span><\/p>\n

                                        Explanation:<\/b><\/p>\n

                                        The special shell parameter <\/span>$?<\/span> contains the exit status returned by the most recently executed foreground pipeline or command, depending on the shell context. A value of <\/span>0<\/span> conventionally indicates successful completion, while a nonzero value generally indicates some form of failure or special condition. Scripts can test this value to make decisions based on whether a previous command succeeded. For example, <\/span>command; echo $?<\/span> can display the command’s exit status. <\/span>$STATUS<\/span>, <\/span>$EXIT<\/span>, and <\/span>$RESULT<\/span> are not the standard special parameter used by POSIX shells for this purpose.<\/span><\/p>\n

                                        Question: 80. Which shell operator executes the command on the right only if the command on the left succeeds?<\/b><\/p>\n

                                          \n
                                        1. <\/b> ||<\/span>
                                          \n<\/span>2.<\/b> &&<\/span>
                                          \n<\/span>3.<\/b> ;;<\/span>
                                          \n<\/span>4.<\/b> |<\/span><\/li>\n<\/ol>\n

                                          Correct Answer:<\/b> 2. <\/span>&&<\/span><\/p>\n

                                          Explanation:<\/b><\/p>\n

                                          The <\/span>&&<\/span> operator allows commands to be conditionally chained so that the command on the right is executed only when the command on the left returns a successful exit status. For example, <\/span>mkdir test && cd test<\/span> attempts to change into the directory only if creating the directory succeeds. The <\/span>||<\/span> operator provides the opposite conditional behavior, executing the right-hand command when the left-hand command fails. The pipe <\/span>|<\/span> connects standard output to standard input, while <\/span>;;<\/span> has specific uses within shell constructs such as <\/span>case<\/span>. Therefore, <\/span>&&<\/span> is the correct operator for success-based command chaining.<\/span><\/p>\n

                                           <\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full LPI 101-500 Exam Dumps and Practice Test Dumps   Question: 61. Which command is commonly used to view a text file one screen at a time with support for scrolling backward and forward? less 2. cat 3. head 4. echo Correct Answer: 1. less Explanation: The less command is commonly used to view […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[1648,1647],"tags":[],"_links":{"self":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18613"}],"collection":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/comments?post=18613"}],"version-history":[{"count":2,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18613\/revisions"}],"predecessor-version":[{"id":18615,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/18613\/revisions\/18615"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=18613"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=18613"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=18613"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}