Use uma casedeclaração (portátil, funciona em qualquer shshell):

case "$CODE" in
    [aA] ) PN="com.tencent.ig" ;;
    [bB] ) PN="com.vng.pubgmobile" ;;
    [cC] ) PN="com.pubg.krmobile" ;;
    [dD] ) PN="com.rekoo.pubgm" ;;
    * ) printf '\a\t%s\n' 'ERROR!' 'CODE KOSONG' 'MELAKUKAN EXIT OTOMATIS' >&2
        exit 1 ;;
esac

Eu também recomendaria alterar seus nomes de variáveis ​​de todas as letras maiúsculas (como CODE) para algo em minúsculas ou mistas (como codeou Code). Existem muitos nomes em maiúsculas que têm significados especiais, e reutilizar um deles por acidente pode causar problemas.

Outras notas: A convenção padrão é enviar mensagens de erro para "erro padrão" em vez de "saída padrão"; o >&2redirecionamento faz isso. Além disso, se um script (ou programa) falhar, é melhor sair com um status diferente de zero ( exit 1), para que qualquer contexto de chamada possa dizer o que deu errado. Também é possível usar diferentes status para indicar problemas diferentes (veja a seção "EXIT CODES" da página curlman para um bom exemplo). (Crédito a Stéphane Chazelas e Monty Harder para sugestões aqui.)

Eu recomendo printfem vez de echo -e(e echo -n), porque é mais portátil entre sistemas operacionais, versões, configurações, etc. Certa vez tive vários scripts quebrados porque uma atualização do sistema operacional incluiu uma versão do bash compilada com opções diferentes, o que mudou o echocomportamento.

As aspas duplas $CODEnão são realmente necessárias aqui. A string em a caseé um dos poucos contextos em que é seguro deixá-los de fora. No entanto, prefiro aspas duplas de referências de variáveis, a menos que haja uma razão específica para não fazê-lo, porque é difícil acompanhar onde é seguro e onde não é, por isso é mais seguro apenas aspas duplas habitualmente.

Supondo que você esteja usando a bashversão 4.0 ou mais recente...

CODE=A

declare -A domain

domain=(
   [a]=com.tencent.ig
   [b]=com.vng.pubgmobile
   [c]=com.pubg.krmobile
   [d]=com.rekoo.pubgm
)

PN=${domain[${CODE,,}]:?ERROR! CODE KOSONG, MELAKUKAN EXIT OTOMATIS}

No código, defino uma matriz associativa contendo todos os nomes de domínio, cada um associado a uma única letra minúscula.

A $PNvariável recebe o nome de domínio correspondente ao $CODEvalor em minúsculas ( ${CODE,,}retorna $CODEapenas o valor de transformado em letras minúsculas) desta matriz, mas se $CODEnão corresponder a uma entrada válida na domainlista, ela sai do script com um erro.

A ${variable:?error message}substituição do parâmetro seria expandida para o valor de $variable(o domínio apropriado no código), mas sairia do script com a mensagem de erro se o valor estiver vazio e não estiver disponível. Você não obtém exatamente a mesma formatação da mensagem de erro que em seu código, mas essencialmente se comportaria da mesma forma se $CODEfosse inválido:

$ bash script.sh
script.sh: line 12: domain[${CODE,,}]: ERROR! CODE KOSONG, MELAKUKAN EXIT OTOMATIS

Se você se preocupa com a contagem de caracteres, podemos encurtar ainda mais:

CODE=A
declare -A domain=( [a]=tencent.ig [b]=vng.pubgmobile [c]=pubg.krmobile [d]=rekoo.pubgm )
PN=com.${domain[${CODE,,}]:?ERROR! CODE KOSONG, MELAKUKAN EXIT OTOMATIS}

Além de excluir novas linhas desnecessárias, também removi com.de cada domínio (isso é adicionado na atribuição a PN).

Observe que todo o código acima funcionaria mesmo para um valor de vários caracteres $CODE(se existissem chaves minúsculas para eles na domainmatriz).

Se $CODEfosse um índice numérico (baseado em zero), isso simplificaria um pouco o código:

CODE=0

domain=( com.tencent.ig com.vng.pubgmobile com.pubg.krmobile com.rekoo.pubgm )
PN=${domain[CODE]:?ERROR! CODE KOSONG, MELAKUKAN EXIT OTOMATIS}

Isso também tornaria muito fácil ler a domainmatriz de um arquivo auxiliar contendo uma entrada por linha:

CODE=0

readarray -t domain <domains.txt
PN=${domain[CODE]:?ERROR! CODE KOSONG, MELAKUKAN EXIT OTOMATIS}

Se o seu shell permitir arrays, a resposta mais curta deve ser como este exemplo no bash:

declare -A site
site=( [a]=com.tencent.ig [b]=com.vng.pubgmobile [c]=com.pubg.krmobile [d]=com.rekoo.pubgm )

pn=${site[${code,}]}

Isso supondo que $codesó poderia ser a, b, c ou d.
Se não, adicione um teste como:

case ${site,} in
    a|b|c|d)        pn=${site[${code,}]};;
    *)              pn="default site"
                    printf '\a\t %s\n' 'ERROR!' 'CODE KOSONG' 'MELAKUKAN EXIT OTOMATIS'
                    exit 1
                    ;;
esac

Vou levar esta resposta em uma direção diferente. Em vez de codificar seus dados no script, coloque esses dados em um arquivo de dados separado e use o código para pesquisar o arquivo:

$ cat names.cfg 
a com.tencent.ig
b com.vng.pubgmobile
c com.pubg.krmobile
d com.rekoo.pubgm

$ cat lookup.sh
PN=$(awk -v code="${1:-}" 'tolower($1) == tolower(code) { print $2; }' names.cfg)
if [ -z "${PN}" ]; then
  printf '\a\t%s\n' 'ERROR!' 'CODE KOSONG' 'MELAKUKAN EXIT OTOMATIS' >&2
  exit 1
fi
echo "${PN}"

$ bash lookup.sh A
com.tencent.ig
$ bash lookup.sh a
com.tencent.ig
$ bash lookup.sh x
    ERROR!
    CODE KOSONG
    MELAKUKAN EXIT OTOMATIS

Separar essas preocupações tem alguns benefícios:

• Adicione e remova dados de maneira fácil e simples, sem precisar contornar a lógica do código.
• Outros programas podem reutilizar os dados, como contar quantas correspondências existem em um subdomínio específico.
• Se você tiver uma lista enorme de dados, poderá classificá-la no disco e usá look-la para pesquisá-la com eficiência binária (em vez de linha por linha grepou awk)

Você está usando letras para indexar os valores, se você usar números, fica tão simples quanto:

code=1
set -- com.tencent.ig com.vng.pubgmobile com.pubg.krmobile com.rekoo.pubgm

eval pn\=\${"$code"}

Esse é o código shell portátil, funcionará na maioria dos shells.
Para bash você pode usar: pn=${!code}, ou para bash/ksh/zsh use: pn=${@:code:1}.

cartas

Se você precisar usar letras (de a a z ou A a Z), elas devem ser convertidas em um índice:

code=a                              # or A, B, C, ... etc.
set -- com.tencent.ig com.vng.pubgmobile com.pubg.krmobile com.rekoo.pubgm
eval pn\=\"\${$(( ($(printf '%d' "'$code")|32)-96  ))}\"

Em um código mais longo para esclarecer a intenção e o significado de cada parte:

code=A

set -- com.tencent.ig com.vng.pubgmobile com.pubg.krmobile com.rekoo.pubgm

asciival=$(( $(printf '%d' "'$code") ))      # byte value of the ASCII letter.
upperval=$(( asciival |  32 ))               # shift to uppercase.
indexval=$(( upperval -  96 ))               # convert to an index from a=1.
eval arg\=\"\$\{$indexval\}\"                # the argument at such index.

Se você precisar converter para valores minúsculos, use: $(( asciival & ~32 ))(certifique-se de que o bit 6 do valor ascii esteja desabilitado).

Erro de código

A saída que seu script imprime em um erro é bastante longa (e particular).
A maneira mais versátil de lidar com isso é definir uma função:

errorcode(){ exitcode=$1; shift; printf '\a\t %s\n' "$@"; exit "$exitcode"; }

E então chame essa função com a(s) mensagem(ns) específica(s) que você precisa.

errorcode 27  "ERROR!" "CODE KOSONG" "MELAKUKAN EXIT OTOMATIS"

Observe que o valor de saída resultante é dado por exitcode(exemplo aqui é 27).

Um script completo (com verificação de erros) se torna:

errorcode(){ exitcode=$1; shift; printf '\a\t %s\n' "$@"; exit "$exitcode"; }

code=${1:-A}

case "$code" in 
    [a-d]|[A-D]) : ;;
    *)           errorcode 27  "ERROR!" "CODE KOSONG" "MELAKUKAN EXIT OTOMATIS" ;;
esac

set -- com.tencent.ig com.vng.pubgmobile com.pubg.krmobile com.rekoo.pubgm
eval pn\=\"\${$(( ($(printf '%d' "'$code") & ~32) - 64  ))}\"

printf 'Code=%s Argument=%s\n' "$code" "$pn"