Linux echo without newline

How to make echo interpret backslash escapes and not print a trailing newline?

I would like to use echo in bash to print out a string of characters followed by only a carriage return. I’ve looked through the man page and have found that echo -e will make echo interpret backslash escape characters. Using that I can say echo -e ‘hello\r’ and it will print like this

So it looks like it handled the carriage return properly. I also found echo -n in the man page will stop echo from inserting a newline character and it looks like it works when I do this

The problem I’m having is in combining both -e and -n . I’ve tried each of echo -e -n ‘hello\r’ , echo -n -e ‘hello\r’ , echo -en ‘hello\r’ , and echo -ne ‘hello\r’ and nothing gets printed like so:

$> echo -ne ‘hello\r’ will leave the cursor at the start of the line containing the ‘hello’. So if your prompt is longer than the $> you have here, it will overwrite the hello.

“nothing gets printed”? Surely you’d get ‘ $>llo ’ because your 2-character prompt-string would not completely overwrite the 5 characters of ‘hello’. Note that ‘carriage return’ isn’t the same as ‘new line’ (see man ascii ). So it seems that you’ve successfully replaced new line with carriage return yet you’re surprised that carriage return doesn’t behave like new line. Why did you want to do this? I’m curious. Also, without the quotes the shell interprets the backslash as an escape character so \r just becomes r . That means your first command actually prints ‘ hellor ’ not ‘ hello ’.

Did you run these commands on the same shell? echo -n hello\r should have outputted exactly the same as echo -ne hello\r ; they both print ‘ hellor ’ (without a new line, so the prompt appears as ‘ hellor$> ’). The -e is irrelevant here because there’s no backslash escape after the shell has stripped it. echo -ne ‘hello\r’ or echo -ne hello\\r both pass the argument ‘ hello\r ’ to echo .

At the time of this writing, only 1 of your 4 examples seems to have the correct result (though I’m not sure about the leading space), but I don’t think that I can edit this question to correct the examples without loosing the original meaning. :-/

5 Answers 5

I think it’s working, you’re just not seeing it. This is your command:

Because of the carriage return ( \r ), that will leave the cursor at the start of the same line on the terminal where it wrote the hello — which means that’s where the next thing output to the terminal will be written. So if your actual prompt is longer than the $> you show here, it will overwrite the hello completely.

This sequence will let you see what’s actually happening:

echo -ne 'hello\r'; sleep 5; echo 'good-bye' 

But for better portability to other shells, I would avoid using options on echo like that. Those are purely bashisms, not supported by the POSIX standard. The printf builtin, however, is specified by POSIX. So if you want to display strings with no newline and parsing of backslash sequences, you can just use it:

There are numerous different implementations of the echo command. There’s one built into most shells (with different behavior for each), and the behavior of /bin/echo varies considerably from one system to another.

Rather than echo , use printf . It’s built into bash as well as being available as an external command, and its behavior is much more consistent across implementations. (The major variation is that the GNU coreutils printf recognizes —help and —version options.)

+1 echo is fine for printing single lines, but as soon as you use any special options or escapes it gets unreliable and unportable. printf is much better for anything like this.

The question is tagged as bash-specific, though. Seems likely the OP doesn’t need portability for their use case.

I’d like you to introduce you to printf.

OP, meet printf . printf . This is the OP.

Whenever you are trying to do anything unusual with output in BASH, you should switch to printf . In fact, I use printf all the time, so my scripts will run under both BASH and Kornshell.

Although BASH and Kornshell are 99% the same, the echo command is different. In Kornshell, it’s deprecated, and you’re supposed to use the builtin print . However, there’s no print in BASH. Using printf solves the problem because it works (sort of) the same in both shells.

Since printf doesn’t automatically end each line with a \n , you don’t have to worry about how to prevent the \n from being appended. Heck, if you want a \n , you have to put it yourself. In your case:

However, for safety reasons, you should really do this:

This is a habit I’ve gotten into when I’m using printf . Imagine if I want to print out $FOO , and I do this:

That will normally work, but what if $FOO has a dash at the beginning, or has a % sign in it. The above won’t do what I want to do. However, if I do this:

This will print out $FOO no matter what $FOO has in it.

Источник

How to Use echo Command Without Newline

Every time you use echo, it adds a newline character at the end. Here’s what you can do if you want to use echo without newline.

The echo command is a handy way of printing anything in shell scripts.

By default, it always adds a new line character. So if you run multiple echo commands, each output is displayed on a new line.

But this could be inconvenient in situations where you need to print with echo command but without the newline.

Imagine yourself trying to print the Fibonacci series: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55

You can use the -n flag of the echo command to print without newline:

You’ll notice that the prompt is displayed in the same line immediately after the Hello World now.

Let’s take a more in-depth look at it.

Printing echo command without new line

Let’s take a simple for loop that prints the contents of an array in bash script and check it’s output.

$ bash_array=(1 2 3 4) $ for i in $; do echo $i done 1 2 3 4

As you can see, each time the echo command is executed, the output is displayed on a newline. Sometimes that is what you want, other times, you want the output to continue on the same line without starting on the newline.

Meet the «-n» flag

The bash implementation of the echo command usually appends a «\n» (an escape character to signify a newline) to the output. The «-n» flag does not append a «\n» to the output.

$ bash_array=(1 2 3 4 5 6 7 8) $ for i in $; do echo -n $i done 12345678

As you can see, all the numbers are now displayed in a single line. This means each time that the echo command was run, it did not output to a newline.

echo -n didn’t work. Now what?

In some cases, using echo -n also prints the -n character instead of printing the text without newline.

That’s possible if there is a separate implementation of the echo command by the shell you are using.

Confused? Some distributions and shells may have their own implementation of some built-in shell commands. echo is one such command.

Here are a few things you may try.

Add the shebang character followed by /bin/bash to ensure that your shell script uses bash shell.

If that doesn’t work, you may try using the printf command instead of echo.

By default, printf doesn’t add the newline character:

printf "Something without newline"

You have to explicitly provide the newline character \n:

printf "Something with newline\n"

The printf command behaves like the printf command in C and you can use it to print more complicated formatted outputs.

The printf command has much more consistent behavior. echo is fine for simple things, but I advise using printf for anything more complicated.

I hope this simple tutorial helps you in controlling the behavior of new line in bash scripts.

Источник

Echo without Newline Character in Bash

When working with bash scripts, you may find the need to print text to the console without a newline character at the end. By default, the echo command in bash appends a newline character at the end of the output. This may not always be desirable, particularly if you need to format the output in a specific way. Fortunately, there are several ways to use echo without a newline character in bash but this article will cover three different methods.

1: How to Use echo without New Line Character Using the -n Option

The most straightforward way to use echo without a newline character is to use the -n option. Here’s an example:

echo -n «Please enter your name: «

The -n option will prevent echo from add a newline character at the end of the output and this will produce the following output:

2: How to Use echo without New Line Character Using the -e Option with Escape Sequences

The -e option enables the interpretation of escape sequences, which can be used to produce output without a newline character. Here’s an example:

echo -e «Please enter your name:\c»

The \c escape sequence tells echo to suppress the newline character. This will produce the following output and note that the -e option is required to enable escape sequence interpretation:

3: How to Use echo without New Line Character Using a Combination of echo and tr Commands

Another way to remove the newline character is to use the tr command to delete it. Here’s an example:

echo -n «Please enter your name: » | tr -d ‘\n’

The tr command is used to delete the newline character (\n) from the output of echo. This will produce the following output:

The first “echo” command is modified to use the “-n” option, which prevents the command from adding a trailing newline character. This means that the prompt for the user’s name will be printed on the same line as the “Please enter your name:” text.

The second “echo” command is modified to include the user’s name in the output using variable expansion (i.e. “$name”). The “-n” option is also used to prevent the command from adding a trailing newline character. The final “echo” command is left unchanged, as it simply prints a blank line to the terminal

Conclusion

These are some of the ways to use echo without a newline character in bash; however, each method has its own advantages and disadvantages, so you should choose the one that best fits your preference. Using the -n option with echo is the simplest and most used method, but the other methods provide additional flexibility for more complex scenarios.

About the author

Aaliyan Javaid

I am an electrical engineer and a technical blogger. My keen interest in embedded systems has led me to write and share my knowledge about them.

Источник

echo to file without new line [duplicate]

I have a config file generated from a program, and I would like to add some text at the end of the last line of the file. Example file:

@fedorqui this thread is marked as duplicate, but I feel that answer is not entirely correct, although this particular thread has a linux tag, while the other does not and so that means GNU sed , which can handle the missing semicolon..

I am not sure if this is really a dupe. This question specifically asks how to do it with echo , and it might be worth to know that a pure echo solution is not possible.

2 Answers 2

Actually, you always append to the last line!

The real problem is that what you consider to be the last line is actually not. If you place a \n everywhere where there is a newline character, it becomes apparent:

With echo alone, you cannot append where you intend; a solution requires reading the file (at least everything beyond the insert position), and writing out again everything beyond the insertion position.

sed can do something like this.

Remark about the solution proposed by agilob:

echo "$(cat file.txt)test" > file.txt 

This is not an in-place insertion; actually it reads the whole file, passes the whole content on the command line to the echo tool, and only after that it will completely overwrite your file.txt . For large files, this can impose severe problems, depending on your shell.

This is unlike a sed solution, which will edit the file while streaming it («live») and therefore is superiour for large files, also w.r.t. performance.

Источник