system command in Perl

perldoc -f system
    system LIST
    system PROGRAM LIST
            Does exactly the same thing as "exec LIST", except that a fork
            is done first, and the parent process waits for the child
            process to complete. Note that argument processing varies
            depending on the number of arguments. If there is more than one
            argument in LIST, or if LIST is an array with more than one
            value, starts the program given by the first element of the list
            with arguments given by the rest of the list. If there is only
            one scalar argument, the argument is checked for shell
            metacharacters, and if there are any, the entire argument is
            passed to the system's command shell for parsing (this is
            "/bin/sh -c" on Unix platforms, but varies on other platforms).
            If there are no shell metacharacters in the argument, it is
            split into words and passed directly to "execvp", which is more
            efficient.

            Beginning with v5.6.0, Perl will attempt to flush all files
            opened for output before any operation that may do a fork, but
            this may not be supported on some platforms (see perlport). To
            be safe, you may need to set $| ($AUTOFLUSH in English) or call
            the "autoflush()" method of "IO::Handle" on any open handles.

            The return value is the exit status of the program as returned
            by the "wait" call. To get the actual exit value, shift right by
            eight (see below). See also "exec". This is *not* what you want
            to use to capture the output from a command, for that you should
            use merely backticks or "qx//", as described in "`STRING`" in
            perlop. Return value of -1 indicates a failure to start the
            program or an error of the wait(2) system call (inspect $! for
            the reason).

            Like "exec", "system" allows you to lie to a program about its
            name if you use the "system PROGRAM LIST" syntax. Again, see
            "exec".

            Since "SIGINT" and "SIGQUIT" are ignored during the execution of
            "system", if you expect your program to terminate on receipt of
            these signals you will need to arrange to do so yourself based
            on the return value.

                @args = ("command", "arg1", "arg2");
                system(@args) == 0
                     or die "system @args failed: $?"

            You can check all the failure possibilities by inspecting $?
            like this:

                if ($? == -1) {
                    print "failed to execute: $!\n";
                }
                elsif ($? & 127) {
                    printf "child died with signal %d, %s coredump\n",
                        ($? & 127),  ($? & 128) ? 'with' : 'without';
                }
                else {
                    printf "child exited with value %d\n", $? >> 8;
                }

            Alternatively you might inspect the value of
            "${^CHILD_ERROR_NATIVE}" with the W*() calls of the POSIX
            extension.

            When the arguments get executed via the system shell, results
            and return codes will be subject to its quirks and capabilities.
            See "`STRING`" in perlop and "exec" for details.