On newer Bash Versions you could simply add a space at the beginning of your command. :)
If it doesn&#39;t work by default, add [ \t]* to HISTIGNORE. (As mentioned in the comments. thx)

Add ***ignorespace*** to your **HISTCONTROL** environment variable. Then any command line that begins with a space won&#39;t be entered into your history.


Recently I wrote a bit of Lua code something like:

    local a = {}
    for i = 1, n do
       local copy = a
       -- alter the values in the copy
    end

Obviously, that wasn&#39;t what I wanted to do since variables hold references to an anonymous table not the values of the table themselves in Lua.  This is clearly laid out in [Programming in Lua](http://www.lua.org/pil/2.5.html), but I&#39;d forgotten about it.

So the question is what should I write instead of `copy = a` to get a copy of the values in `a`?



How do you copy a Lua table by value?

I came across a function definition:

    char* abc(char *f, ...)
    {
    }

What do the three dots mean?

Question about a function definition (three dots in parameters..)

Is there a way to prevent a command from being added to the bash shell&#39;s command history?

I would like to be able to prevent certain &quot;dangerous&quot; commands from being added to the history, such as &quot;`rm -rf ~/some/dir`&quot;, so that it is not accessible to me by pressing the up-arrow to reach previous commands.  In this way, it would not be possible to accidentally repeat one of these commands.

The reason I ask is that I use the up arrow a lot to access previous commands in the shell history, and have often caught myself about to hit enter on what I **thought** was the correct command, only to realise that I was about to do something stupid/annoying/dangerous.  I don&#39;t like the idea of `rm`s etc floating around in my shell history, waiting for me to step on them!

(Note: I am aware that one can set up patterns in HISTIGNORE, but what would be nice is something one can apply on a per-command basis, which would become good a habit.  Unless there is a clever way to achieve this using HISTIGNORE that I have missed?)

Can you prevent a command from going into the bash shell command history?

Is there a way to prevent a command from being added to the bash shell's command history?
I would like to be able to prevent certain "dangerous" commands from being added to the history, such as "<code>rm -rf ~/some/dir</code>", so that it is not accessible to me by pressing the up-arrow to reach previous commands. In this way, it would not be possible to accidentally repeat one of these commands.
The reason I ask is that I use the up arrow a lot to access previous commands in the shell history, and have often caught myself about to hit enter on what I thought was the correct command, only to realise that I was about to do something stupid/annoying/dangerous. I don't like the idea of <code>rm</code>s etc floating around in my shell history, waiting for me to step on them!
(Note: I am aware that one can set up patterns in HISTIGNORE, but what would be nice is something one can apply on a per-command basis, which would become good a habit. Unless there is a clever way to achieve this using HISTIGNORE that I have missed?)

Bash scripts are very useful and can save a lot of programming time. So how do you start a bash script in a C++ program? Also if you know how to make user become the super-user that would be nice also. Thanks!

How to run a bash script from C++ program

&gt; **Possible Duplicate:**  
&gt; [How can I run an external program from C and parse its output?](https://stackoverflow.com/questions/43116/how-can-i-run-an-external-program-from-c-and-parse-its-output)  

&lt;!-- End of automatically inserted text --&gt;

I want to run a command in linux and get the text returned of what it outputs, but I **do not** want this text printed to screen. Is there a more elegant way than making a temporary file?



C: Run a System Command and Get Output?

Has anyone an idea how many tcp-socket connections are possible on a modern standard Linux server?

(There is in general less traffic on each connection, but all the connections have to be up all the time.)

How many socket connections possible?

I have a disk drive where the inode usage is 100% (using `df -i` command).
However after deleting files substantially, the usage remains 100%. 

What&#39;s the correct way to do it then?

How is it possible that a disk drive with less disk space usage can have
higher Inode usage than disk drive with higher disk space usage?

Is it possible if I zip lot of files would that reduce the used `inode` count?

How to Free Inode Usage?

What is the difference between these two file types. I see that my C++ app links against both types during the construction of the executable. 

How to build .a files? links, references, and especially examples, are highly appreciated.

.o files vs .a files

I want my bash script to sleep until a specific time. So, I want a command like &quot;sleep&quot; which takes no interval but an end time and sleeps until then.

The &quot;at&quot;-daemon is not a solution, as I need to block a running script until a certain date/time.

Is there such a command?

Sleep until a specific time/date

In editors/ides such as eclipse and textmate, there are shortcuts to quickly find a particular file in a project directory.

Is there a similar tool to do full path completion on filenames within a directory (recursively), in bash or other shell?

I have projects with alot of directories, and deep ones at that (sigh, java).
Hitting tab in the shell only cycles thru files in the immediate directory, thats not enough =/

Find file in directory from command line

What is the best way to move around on a given very long command line in the terminal?

Say I used the arrow key or &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;R&lt;/kbd&gt; to get this long command line:

    ./cmd --option1 --option2 --option3 --option4 --option5 --option6 --option7 --option8 --option9 --option10 --option11 --option12 --option13 --option14 --option15 --option16 --option17 --option18 --option19 --option20 --option21 --option22 --option23 --option24 --option25 --option26 --option27 --option28 --option29 --option30 --option31 --option32 --option33 --option34 --option35 --option36 --option37 --option38 --option39 --option40 --option41 --option42 --option43 --option44 --option45 --option46 --option47 --option48 --option49 --option50 

Now I need to move (starting from the beginning or the end of the line) the cursor to `--option25` to modify something there. 

What is the fastest way to get there? What I usually do is &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;A&lt;/kbd&gt; to get to the beginning and then repeatedly &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;F&lt;/kbd&gt; to move forward, word by word (or &lt;kbd&gt;Ctrl&lt;/kbd&gt;-&lt;kbd&gt;E&lt;/kbd&gt; to go the end and &lt;kbd&gt;Alt&lt;/kbd&gt;-&lt;kbd&gt;B&lt;/kbd&gt; to then go backward). But on a long line that takes too much time. There must be a way to search and jump directly to the part I need to modify, e.g. `option25`?


Fastest way(s) to move the cursor on a terminal command line?

A coworker claimed recently in a code review that the `[[ ]]` construct is to be preferred over `[ ]` in constructs like

    if [ &quot;`id -nu`&quot; = &quot;$someuser&quot; ] ; then
         echo &quot;I love you madly, $someuser&quot;
    fi

He couldn&#39;t provide a rationale. Is there one?



Are double square brackets [[ ]] preferable over single square brackets [ ] in Bash?

i need to find the host name of a UNIX host whose IP is known with out login to that UNIX host

how to find host name from IP with out login to the host

Is there a convention for documenting shell scripts&#39; parameters?

For example:

    #!/usr/bin/env bash
    
    # &lt;description&gt;
    #
    # Usage:
    #  $ ./myScript param1 [param2]
    # * param1: &lt;description&gt;
    # * param2: &lt;description&gt;

A few things I don&#39;t like about this particular template:

 - the script&#39;s file name (`myScript`) appears within the file itself
 - parameter description seems weird
 - the leading space before `$` is visually useful, but can lead to confusion in languages with block comments, causing some validation tools to complain about mixed/inconsisent indentation (e.g. spaces in this block, tabs for code - provided one prefers tabs, of course)

Are there any guidelines on this?

documenting shell scripts&#39; parameters

Where can I find a **well-respected reference** that details the proper handling of PID files on Unix?

On Unix operating systems, it is common practice to “lock” a program (often a daemon) by use of a special lock file: the PID file.

This is a file in a predictable location, often ‘/var/run/foo.pid’. The program is supposed to check when it starts up whether the PID file exists and, if the file does exist, exit with an error. So it&#39;s a kind of advisory, collaborative locking mechanism.

The file contains a single line of text, being the numeric process ID (hence the name “PID file”) of the process that currently holds the lock; this allows an easy way to automate sending a signal to the process that holds the lock.

What I can&#39;t find is a good reference on expected or “best practice” behaviour for handling PID files. There are various nuances: how to actually lock the file (don&#39;t bother? use the kernel? what about platform incompatibilities?), handling stale locks (silently delete them? when to check?), when exactly to acquire and release the lock, and so forth.

Where can I find a **respected, most-authoritative reference** (ideally on the level of W. Richard Stevens) for this small topic?


Reference for proper handling of PID file on Unix

I know how to use `tee` to write the output ([standard output][1]) of `aaa.sh` to `bbb.out`, while still displaying it in the terminal:

```lang-none
./aaa.sh | tee bbb.out
```

How would I now also write [standard error][2] to a file named `ccc.out`, while still having it displayed?

  [1]: https://en.wikipedia.org/wiki/Standard_streams#Standard_output_.28stdout.29
  [2]: https://en.wikipedia.org/wiki/Standard_streams#Standard_error_(stderr)





How do I write standard error to a file while using &quot;tee&quot; with a pipe?

I run across many shell scripts with variables in all caps, and I&#39;ve always thought that there is a severe misunderstanding with that.  My understanding is that, by convention (and perhaps by necessity long ago), **environment variables** are in all-caps.

But in modern scripting environments like Bash, I have always preferred the convention of lower-case names for temporary variables, and upper-case ones *only for exported (i.e. environment) variables*.  For example:

    #!/usr/bin/env bash
    year=`date +%Y`
    echo &quot;It is $year.&quot;
    export JAVA_HOME=&quot;$HOME/java&quot;

That has always been my take on things.  Are there any authoritative sources which either agree or disagree with this approach, or is it purely a matter of style?

Correct Bash and shell script variable capitalization

We required a script that simulates Associative arrays or Map like data structure for Shell Scripting, any body?



Content Type	Original Author	Original Content on Stackoverflow
Question	KarstenF	View Question on Stackoverflow
Solution 1 - Linux	Node	View Answer on Stackoverflow
Solution 2 - Linux	T-Hawk	View Answer on Stackoverflow

Can you prevent a command from going into the bash shell command history?

Linux Problem Overview

Linux Solutions

Solution 1 - Linux

Solution 2 - Linux

Question about a function definition (three dots in parameters..)

How do you copy a Lua table by value?

Attributions