Se a coluna tiver vários valores, copie a linha com cada valor separadamente

Você pode fazer isso awkdividindo a coluna composta ,e fazendo um loop sobre o resultado:

awk -F'\t' 'BEGIN{OFS=FS} {n=split($2,a,/,/); for(i=1;i<=n;i++){$2 = a[i]; print}}' file

Talvez de forma mais clara, você poderia fazer isso com Miller - em particular, usando o verbo nest :

$ cat file
C1      C2      C3
a       b,c     d
e       f,g,h   i
j       k       l

$ mlr --tsv nest --explode --values --across-records --nested-fs ',' -f C2 file
C1      C2      C3
a       b       d
a       c       d
e       f       i
e       g       i
e       h       i
j       k       l

Mais compactamente --explode --values --across-records --nested-fs ','pode ser substituído por--evar ','

Como você também marcou a pergunta com sed, sinto-me convidado a adicionar uma sedsolução:

sed -e '/,/{s//\n/;h;s/[^\t]*\n//;x;s/\n[^\t]*//p;G;D;}'

_{(Nota: Para legibilidade eu usei \npara nova linha e \tpara tab como você pode fazer com GNU sed. Para uma solução portátil, use uma barra invertida com uma nova linha real em vez de \ne uma tabulação real para \t, inserido ctrlVseguido por tab)}

As linhas com uma vírgula são copiadas para o espaço de espera, uma cópia é impressa com o que está antes da vírgula, a outra cópia vai para o próximo ciclo com a parte após a vírgula. Em detalhe:

• Para evitar confusão com várias vírgulas, substituímos uma por uma nova linhas//\n/
• salve uma cópia no hespaço antigo antes de estragar a linha
• s/[^\t]*\n//remove a parte até a primeira vírgula
• então nós xmudamos os buffers
• s/\n[^\t]*//premove a parte a partir da vírgula e a imprime
• Gacrescenta o espaço de espera ao espaço de padrão. Isso pode conter vírgulas de adição, então
• Dremove a primeira linha (já impressa) e recomeça com o resto da linha

awk(ou perlno awkmodo) é provavelmente a melhor solução padrão, mas você pode fazer isso de forma razoavelmente eficiente na maioria dos shells, especialmente aqueles com arrays ( ksh, bash, zsh):

set -f # split but don't glob unquoted substitutions
#bash
while IFS=$'\t' read -ra ary; do 
#ksh
while read -r line; do IFS=$'\t'; ary=($line)
#zsh I haven't worked out

  IFS=,; for v in ${ary[17]}; do 
    ary[17]=$v; IFS=$'\t'; printf '%s\n' "${ary[*]}"
  done
  # bash,ksh arrays are 0-origin versus 1-origin fields in awk
  # we don't need to special-case no-comma, it splits to a single value
done <input >output

Para shells antigos/limitados sem arrays, use os parâmetros posicionais como (pode variar):

set -f
while read -r line; do IFS=$'\t'; set -- $line
  IFS=,; for v in ${18}; do
    # can't alter $num so yucky
    for i in $(seq $#); do
      case $i in (1);; (*) printf '\t';; esac
      case $i in (18) printf %s "$v";; (*) eval printf %s \"\${$i}\";; esac
    done
    # or maybe i=1; while [ $i -le $# ]; do ... i=$((i+1)); done
    # where [/test is likely shell builtin and seq is unlikely 
  done
done <input >output

Usando perl

## Column of Interest
CoI=2 
perl -sF'\t' -aple '$"="\t";
  $_ = join $\, map { $F[$I]=$_;"@F" } split /,/, $F[$I]
' -- -I="$((CoI-1))" file

• perlopções usadas:-

  • -p isso faz com que o Perl leia um arquivo linha por linha e produza a linha antes do próximo ciclo.
  • -a liga o modo de divisão automática, em que o registro de entrada ($_) é dividido e os componentes colocados no array (@F)
  • -l faz com que o separador de registro de entrada e o separador de registro de saída sejam novas linhas.
  • -s liga o processamento rudimentar do switch. Com sua ajuda, definimos uma variável global $I na linha de comando.
  • -F separador de campo especificado aqui
  • -e Código Perl especificado aqui.

• perlvariáveis ​​internas usadas: -

  • $_ registro atual sendo processado.
  • $" junção de elementos de matriz
  • @F campos de divisão de registro atual armazenados nesta matriz. É indexado a zero
  • $\ separador de registro de saída

• Código Perl:-

  • divida a coluna de interesse $F[$I] em torno de vírgula e atribua progressivamente os elementos de divisão à coluna se interesse e junte a matriz @F com a variável $" e atribua ao registro de entrada ($_)
  • a ação padrão é imprimir automaticamente o registro de entrada.

CoI=2
awk -F '\t' -v coi="$CoI" '
BEGIN { OFS=FS;s[1]=ORS }
NF >= coi {
  split($(coi),a,",")
  for (i=t=""; ++i in a;) {
    $(coi) = a[i]
    t = t s[i>1] $0
  }
  $0=t
}1
' file

Usando GNU sed no modo regex estendido (-E):

CoI=2
sed -E '
  s/[^\t]+/\n&\n/'"$CoI"'
  s/(\n.*)(\n.*)/\2\1,/
  :loop
    s/\n(.*\n)([^,]+),/\2\1/
    P;/\n$/d
    s/[^\t]+/\n/'"$CoI"'
  tloop
' file

Esta é uma operação de progresso em um registro do que o sed está fazendo:

   pat_spc       output
 a b,c,d e         -
 a \nb,c,d\n e     -
 a \n e\nb,c,d,    -
 a b e\nc,d,      a b e
 a \n e\c,d,        -
 a c e\nd,        a c e
 a \n e\nd,         -
 a d e\n          a d e
/\n$/ stop, fetch next line

CoI=2
python3 -c 'import sys

ifile,coi = sys.argv[1:]
coi = int(coi)-1
fs,rs,ofs,ors = ("\t","\n") * 2

with open(ifile) as f:
  for l in f:
    F = l.rstrip(rs).split(fs)
    for e in F[coi].split(","):
      F[coi] = e
      print(*F,sep=ofs)
' file "$CoI"

com bourne shell embutido usando array de parâmetros posicionais

cleanup() {
  echo cleaning up temp files... >&2
  /bin/rm -f -- "$temp"
}
trap cleanup EXIT
set -u

#-------------------+
# user input section
#-------------------+
CoI=2
inp='inmuebles.txt'
#-------------------+

: <<\_README_
1. CoI standing for column of interest.
2. CoT must be a positive integer.
3. CoI must not be more than the number of fields in the unput.
4. inp stores the input file name, 
possibly with full or relative path, to make it accessible to the script.
5. All lines must have same number of fields.
6. No field to have TAB and/or newline.
7. Field separator is TAB.
8. File should be readable by the user and be a regular ascii text file.
_README_

IFS=$(printf '\t')
temp=$(mktemp) del=

while IFS= read -r line <&3
do
  set -f;set -- $line;set +f

  : ${del:=$(dc <<eof
1 $# $CoI-+n
eof
)}

  while case $# in "$del") break;; esac
  do
    printf '%s\t' "$1"
    shift
  done > "$temp"

  x1=$1;shift

  for csv in $(set -f;IFS=',';set -- $x1;printf '%s\t' "$@")
  do
    printf '%s' "$(cat < "$temp")" "$csv"
    case $# in 0) echo; break;; esac
    printf '\t%s\n' "$*"
  done
done 3< "$inp"

 while read line
 do
 fic=$(echo $line | awk '{print $1}')
 laco=$(echo $line | awk '{print $NF}')
 secon_colu=$(echo $line| awk '$2 ~ /,/{print $2}')
 if [[ "$secon_colu" =~ "," ]]
 then
 for ko in $(echo $line | awk '$2 ~ /,/{print $2}'| sed 's/,/ /g')
 do
 echo "$fic $ko  $laco"
 done
 else
 echo $line
 fi
 done<file.txt

resultado

C1 C2 C3
a b  d
a c  d
e f  i
e g  i
e h  i
j k l