How to convert text file from lower-case to upper case and save as new file

Question

Please would someone be able to explain how I can convert all the lower case characters in a text file to upper case and then save it as a new file? My file is called NewFile.txt and contains 500 lines of random characters.

Answer 1

In the POSIX toolchest, there's:

<input.txt tr '[:lower:]' '[:upper:]' >output.txt

However note that with the GNU implementation, that only works for single-byte characters; so in locales using the UTF-8 charset for instance, only on abcdefghijklmnopqrstuvwxyz letters without diacritics.

<input.txt awk '{print toupper($0)}' >output.txt

is also POSIX and works OK with the GNU implementation of awk.

<input.txt dd conv=ucase >output.txt

is also POSIX but not many implementations will transliterate non-ASCII characters.

<input.txt sed 's/.*/\U&/g' > output.txt

Works in GNU sed, but GNU sed only (that \U is not standard).

With perl:

<input.txt perl -Mopen=locale -pe '$_=uc' >output.txt

That one doesn't use the locale's toupper rules, so may work better on words like office (converting that one ffi character to the three character FFI¹).

uconv, from the ICU project should be pretty good at handling all sorts of international corner cases, and assuming input / output encoded in UTF-8 (or whatever uconv --default-code returns; though see the -f/--from-code and -t/--to-code options to specify different input and output encodings):

<input.txt uconv -x upper >output.txt

Within the vim editor, if on the first character of the file (gg to get there), enter gUG to convert all to uppercase til the end of the file. Then :saveas output.txt to save to output file.

Or with any ex or vi implementation (though not all will handle non-ASCII characters): :%s/.*/\U&/ (and :w output.txt to write the edited file to output.txt and :q! to quit without saving the now modified input file).

With the zsh shell:

zmodload zsh/mapfile
mapfile[output.txt]=${(U)mapfile[input.txt]}
# or (csh-style):
mapfile[output.txt]=$mapfile[input.txt]:u

To convert from upper to lower case instead, in case that's not already obvious:

• tr: swap [:lower:] and [:upper:]
• awk: change toupper to tolower
• dd: change ucase to lcase
• GNU sed / ex / vi: change \U to \L
• perl: change uc to lc.
• uconv: change upper to lower
• vim: change gUG to guG (that's the trick one).
• zsh: change (U) to (L), :u to :l.

---

^{¹ the C / POSIX toupper() / towupper() API only converts one character to another one at a time, so is limited in how it can change the case of text. See https://unicode-org.github.io/icu/userguide/icu/posix.html#case-mappings about that and more.}

Answer 2

A bash one(ish) liner using only builtins...

f="$(< infile.txt)" ; printf "%s" "${f^^}" > outfile.txt ; unset f

We fill temporary variable f with the content of infile.txt.

Then we print f to STDOUT while using bash variable trickery to uppercase it (${f^^}) and redirect STDOUT to outfile.txt.

Caveat: Probably going to play up if the "randomness" deviates from Latin and printable characters. Also drops any trailing newlines.

Per comments, this is probably better (more efficient, no newline dropping):

readarray f < infile.txt ; printf %s "${f[@]^^}" > outfile.txt ; unset f

Answer 3

You can do it in the command line using GNU sed (what you are most likely using on your Linux system):

sed -e 's/\([a-z]\)/\U\1/g' filename >newfilename

Explanation:

sed is a program you can use to process a stream of strings into something else using regular expressions. It accepts input from standard input or from a file, and writes to standard output.

Now to break down the regular expression used:

to do a substitution, you use the syntax s/<expression>/<new_expression>/g. You use one expression to find the matching text you want to substitute and the other to dictate how to replace. The regular expression we used to find the match was ([a-z]) (ignoring the backslashes which escape the parentheses). This regular expression looks for any lower case character; surrounding the expression with parentheses lets us save the character for future reference.

Then, for the substitution, we use \U\1, where \U converts to upper case ("U" for upper), and \1 is the character we saved by surrounding the regex with parentheses

---

Further Reading:

• Back-references and Subexpressions. These are the parentheses we used to save the match for future reference and referred to it again with \1
• Upper/Lower case conversion. Here you will find a detailed description of \U, as well as other operators you can use for conversion

Answer 4

A perl one-liners are a fun way of doing this.

perl -ne 'print uc' NewFile.txt > output.txt

The -n assigns each line to $_ which is passed as a default argument to uc (uppercase) and is executed with -e. Or you could use

perl -pe '$_ = uc' NewFile.txt > output.txt

where the -p is the same as -n, but adds an implicit print $_ to the end of the -e command.

A big motto in Perl is There Is More Than One Way To Do It.

Answer 5

The suggested sed-oneliners (@Stéphane Chazelas, @Kusalananda) all use the "s"-subcommand, which is not the best tool for the job. Changing one (set of) character(s) to another is easier and better done with "y":

sed 'y/abcde/ABCDE/' infile > outfile

will translate any occurrence of the first character in the first string to the first character in the second string, any occurrence of the second character in the first string to the second character in the second string and so on. Replace in the above the "abcde"-strings with whatever "character translation table" you want and you can convert files with any character set/encoding sed is able to handle.