Using curl to get help on Linux commands, programming languages and more. The most comprehensive cheat sheet.
If you are looking for a Linux and programming cheat sheet, please check
https://github.com/chubin/cheat.sh
It provides nicely colored help page, with plenty of examples in a CLI. Here are some sample runs I did.
Curl cheat sheet
daniel@hidmo:/tmp$ curl cheat.sh/curl
# Download a single file
curl http://path.to.the/file
# Download a file and specify a new filename
curl http://example.com/file.zip -o new_file.zip
# Download multiple files
curl -O URLOfFirstFile -O URLOfSecondFile
# Download all sequentially numbered files (1-24)
curl http://example.com/pic[1-24].jpg
# Download a file and follow redirects
curl -L http://example.com/file
# Download a file and pass HTTP Authentication
curl -u username:password URL
# Download a file with a Proxy
curl -x proxysever.server.com:PORT http://addressiwantto.access
# Download a file from FTP
curl -u username:password -O ftp://example.com/pub/file.zip
# Get an FTP directory listing
curl ftp://username:password@example.com
# Resume a previously failed download
curl -C - -o partial_file.zip http://example.com/file.zip
# Fetch only the HTTP headers from a response
curl -I http://example.com
# Fetch your external IP and network info as JSON
curl http://ifconfig.me/all/json
# Limit the rate of a download
curl --limit-rate 1000B -O http://path.to.the/file
# POST to a form
curl -F "name=user" -F "password=test" http://example.com
# POST JSON Data
curl -H "Content-Type: application/json" -X POST -d '{"user":"bob","pass":"123"}' http://example.com
# POST data from the standard in / share data on sprunge.us
curl -F 'sprunge=<-' sprunge.us
Python lists cheat list
daniel@hidmo:/tmp$ curl cheat.sh/python/list
# python - Why does += behave unexpectedly on lists?
#
# The general answer is that += tries to call the __iadd__ special
# method, and if that isn't available it tries to use __add__ instead.
# So the issue is with the difference between these special methods.
#
# The __iadd__ special method is for an in-place addition, that is it
# mutates the object that it acts on. The __add__ special method returns
# a new object and is also used for the standard + operator.
#
# So when the += operator is used on an object which has an __iadd__
# defined the object is modified in place. Otherwise it will instead try
# to use the plain __add__ and return a new object.
#
# That is why for mutable types like lists += changes the object's
# value, whereas for immutable types like tuples, strings and integers a
# new object is returned instead (a += b becomes equivalent to a = a +
# b).
#
# For types that support both __iadd__ and __add__ you therefore have to
# be careful which one you use. a += b will call __iadd__ and mutate a,
# whereas a = a + b will create a new object and assign it to a. They
# are not the same operation!
>>> a1 = a2 = [1, 2]
>>> b1 = b2 = [1, 2]
>>> a1 += [3] # Uses __iadd__, modifies a1 in-place
>>> b1 = b1 + [3] # Uses __add__, creates new list, assigns it to b1
>>> a2
[1, 2, 3] # a1 and a2 are still the same list
>>> b2
[1, 2] # whereas only b1 was changed
# For immutable types (where you don't have an __iadd__) a += b and a =
# a + b are equivalent. This is what lets you use += on immutable types,
# which might seem a strange design decision until you consider that
# otherwise you couldn't use += on immutable types like numbers!
#
# [Scott Griffiths] [so/q/2347265] [cc by-sa 3.0]
Golang concurrency cheat sheet
daniel@hidmo:/tmp$ curl cheat.sh/go/concurrency
/*
* go - When should I use concurrency in golang?
*
* Not an expert in Go (yet) but I'd say:
*
* Whenever it is easiest to do so.
*
* The beauty of the concurrency model in Go is that it is not
* fundamentally a multi-core architecture with checks and balances where
* things usually break - it is a multi-threaded paradigm that not only
* fits well into a multi-core architecture, it also fits well into a
* distributed system architecture.
*
* You do not have to make special arrangements for multiple goroutines
* to work together harmoniously - they just do!
*
* Here's an example of a naturally concurrent algorithm - I want to
* merge multiple channels into one. Once all of the input channels are
* exhausted I want to close the output channel.
*
* It is just simpler to use concurrency - in fact it doesn't even look
* like concurrency - it looks almost procedural.
*/
/*
Multiplex a number of channels into one.
*/
func Mux(channels []chan big.Int) chan big.Int {
// Count down as each channel closes. When hits zero - close ch.
var wg sync.WaitGroup
wg.Add(len(channels))
// The channel to output to.
ch := make(chan big.Int, len(channels))
// Make one go per channel.
for _, c := range channels {
go func(c <-chan big.Int) {
// Pump it.
for x := range c {
ch <- x
}
// It closed.
wg.Done()
}(c)
}
// Close the channel when the pumping is finished.
go func() {
// Wait for everyone to be done.
wg.Wait()
// Close.
close(ch)
}()
return ch
}
/*
* The only concession I have to make to concurrency here is to use a
* sync.WaitGroup as a counter for concurrent counting.
*
* Note that this is not purely my own work - I had a great deal of help
* with this here (https:stackoverflow.com/q/19192377/823393).
*
* [OldCurmudgeon] [so/q/19747950] [cc by-sa 3.0]
*/
Please check
https://github.com/chubin/cheat.sh for more information on installation and using its comprehensive features.
