You have the option of capturing the SIGINT signal using Bash's builtin trap:

trap [COMMANDS] [SIGNALS]

You can, for example, capture a SIGINT that was sent to the script in the foreground to send a signal to the process that was forked from the script.

In this case, however, you'll need the PID of the forked process. You can make use of Bash's $! variable, but it only works for processes that were forked to the background.

As a workaround, to preserve the synchronous nature of your script, you can explicitly call wait on the returned PID.

#!/usr/bin/env bash

function skip() {
  kill -SIGTERM $!
}

trap skip SIGINT

ping ... &
wait $!

wget ... &
wait $!

unzip ... &
wait $!

You could black list items from the list of functions that are called by default. Something like:

#!/bin/bash

list='a b c d e f g h i'

# define some functions
for name in $list; do
        eval "func_$name() { echo func_$name called with arg \$1; }"
done

# black list items from list
for x; do
        list=$(echo "$list" | tr -d ${x#-})
done

for name in $list; do
        func_$name $name
done

But frankly it makes more sense to do something like:

$ cat script.sh 
#!/bin/bash

list='a b c d e f g h i'
test $# = 0 && set -- $list # set default list of functions to call

# define some function
for name in $list; do
        eval "func_$name() { echo func_$name called with arg \$1; }"
done

for name; do
        func_$name $name
done
$ bash ./script.sh 
func_a called with arg a
func_b called with arg b
func_c called with arg c
func_d called with arg d
func_e called with arg e
func_f called with arg f
func_g called with arg g
func_h called with arg h
func_i called with arg i
$ bash ./script.sh c g
func_c called with arg c
func_g called with arg g

There's no thing like skipping as you would like. Arguments are just numbered, if there's no second parameter then… well, there's actually no third parameter. So either you explicitly give an emptry string as second parameter (if your exercise permits this), or you check how many parameters are given and in case it's two, take the second parameter as third (since it's a school assignment, I won't go into detail here, just have a look at the description of the $# special variable in your shell's manual).

Easiest way I found to remove the first ten lines of a file:

$ sed 1,10d file.txt

In the general case where X is the number of initial lines to delete, credit to commenters and editors for this:

$ sed 1,Xd file.txt

Commands which are part of the bash syntax, have to be right in a script. But you are speaking about the result of the execution of a program called by this bash script. $? is the value returned by the last executed command. You can use it to make decisions in the following part of the bash script. Unfortunately, according to man pages of the host and dig commands, there is no useful code returned.

You have the general capability to redirect the output of the dig or host commands and to analyze it using commands like grep or awk. But you are depending on the exact syntax of the output of these programs. This syntax can change in future releases of these programs.

Please note a discrepancy in your question. Your host command is asking about example-domain.com and the cited output is related to exa--mple.com. Further, it is better to always ask about absolute domain names, i.e. ending with a period.

moving:

• to the end of the command: ctrl-e
• to the begin of the command: ctrl-a
• forward a word: alt-f
• backword a word: alt-b

deleting:

• from current cursor position to the end of word: ald-d
• from current cursor position to the begin of word: clt-w

example:

• touch .gitignore
• cltr-a (go to the begin)
• alt-d (delete "touch")
• type "code" => code .gitignore