Shell Programming and Scripting

Try this:

Code:

awk -F, '{sub($a FS,x)} sub($(b-1) FS,x)' a=7 b=12 file

Should work without brackets too
awk -F, 'sub($a FS,x) sub($(b-1) FS,x)' a=7 b=12 file

This works by changing the column and its filed separator $a FS to x
Since x is not defined, it will be blank.

This is done.. Thanks Everybody for your helps

Or you can use cut

Code:

m=7
n=12
cut -d, --complement -s -f$m,$n file

The first and last columns won't have an extra pair of comma if they are deleted so FS "+" would not work. Also if one column was originally empty that column would also be deleted. It's better to just use split and array looping instead:

Code:

awk -v m=3 -v n=9 -- '{
    last = split($0, a, /,/)
    append = 0
    for (i = 1; i < last; ++i) {
        if (i != m && i != n) {
            if (append) {
                printf "," a[i]
            } else {
                printf a[i]
                append = 1
            }
        }
    }
    print ""
}' file

Or

Code:

awk -v m=3 -v n=9 -- '{ last = split($0, a, /,/); append = 0; for (i = 1; i < last; ++i) { if (i != m && i != n) { if (append) { printf "," a[i]; } else { printf a[i]; append = 1; }; }; } print ""; }' file

If we use bash for the shell it could be simpler:

Code:

#!/bin/bash

function remove_columns {
    local A LINE IFS=,
    while read -ra LINE; do
        for A; do
            unset "LINE[$A]"
        done
        echo "${LINE[*]}"
    done
}

remove_columns "$m" "$n" < file  ## could be more than two columns specified

These suggestions should not be trusted for a moment. Blindly treating literal text data as regular expressions is asking for trouble. Both sub($a FS, x) and sub($(b-1) FS, x) are problematic in multiple respects.

If that text contains a regular expression metacharacter, who knows where in $0 and how much of $0 it will match.

Even if there are no metacharacters, neither substitution is guaranteed to occur at the correct field; if a preceding field matches the regular expression, that earlier field takes precedence. For example, if a is 5, nothing prevents $5 FS from matching at any point between $1 and $5 inclusive.

If there are metacharacters, the situation is worse, because then a literal string when treated as a regular expression may not even match itself. For example, both of the following expressions are false: "(1)" FS ~ "(1)" FS and "[a]" FS ~ "[a]" FS. This means that for a=5 $5 FS may not match itself but it could match at some other location, both before or after $5.

In Franklin52's code, since the numeric return value of sub($(b-1) FS,x) evaluated in a boolean context controls printing, and since (as just pointed out) literal text as a regular expression may not match itself, entire records could be silently deleted if the controlling sub makes no substitutions.

In Jotne's version, the two numeric return values are converted to strings, concatenated, and the result is evaluated in a boolean context. Since there will always be a numeric return value, and since no number converts to a null string, the string which is evaluated in a boolean context is never empty and so is always true. Even if there were no other problems with the code, I would recommend against this because of the subtlety involved. The chances are extremely high that whoever inherits this code will not fully understand it.

Finally, there's also the possibility that the text is an undefined regular expression, which could produce different output on different awk implementations given identical input.



Great solution, so long as portability isn't a concern.

If portability is a constraint, --complement is disallowed. In which case using cut would require constructing the -f option-argument from $m and $n, yielding something similar to 1-($m-1),($m+1)-($n-1),($n+1)-. However, the logic required to properly handle all boundary conditions isn't worth the trouble when there's a simple, portable AWK solution available (presented below).



I agree with you that the best (only?) AWK solution is to iterate over the fields, excluding the undesirables. It is a robust approach that's immune to all the problems arising from treating literal text as regular expressions.

I did not test your code, but looking at it there appears to be an off-by-one bug at i < last. last corresponds to the final field and it is never printed. It should be i <= last.

Aside from that, your implementation is also a bit overcomplicated. There is no need to explicitly split the record into an array when AWK has already split it into field variables for your convenience.

For portability, simplicty, and flexibility, I recommend:

Code:

{
    for (i=1; i<=NF; i++)
        if (i != m  &&  i != n)
            s = s OFS $i
    print substr(s, length(OFS)+1)
    s=""
}

Obviously, FS and OFS must be set to the appropriate values.



For the sake of those who follow in your footsteps, seeking a solution to an identical or similar problem, the least you can do is state how you solved your problem. This is especially true if all the suggestions provided to you were inadequate and you either crafted your own approach or found one elsewhere.

Regards,
Alister

Another formatting trick

Code:

{
  sep=""
  for (i=1; i<=NF; i++)
    if (i != m  &&  i != n) {
      printf sep"%s", $i
      sep=OFS
    }
  print ""
}