The Six Nations 2012 cheat sheet is an essential guide for rugby fans. Includes the 2011 table and results, full fixture list, Six Nations teams world rankings, a little Six Nations trivia and even current odds on the eventual winner.

Downloads

The Wikipedia cheat sheet is a one-page reference sheet for budding Wikipedia editors, including formating tips, some handy links and a run-down of some of the more common shortcuts and abbreviations used on Wikipedia.

Contents

The Wikipedia cheat sheet includes:

• Headings
• Text Effects
• Links
• Lists and Indents
• Lines and Signatures
• Allowed HTML Tags
• Tables
• Images
• Citations
• Useful Pages
• Abbreviations and Shortcuts

Downloads

The Vimeo API cheat sheet is for those of you who work with the Vimeo advanced API, and need a quick reference for their API methods.

Downloads

The Kings and Queens of the United Kingdom cheat sheet is a one-page reference sheet for UK historians, listed monarchs and their reigns since William the Conqueror.

Contents

The Kings and Queens of the United Kingdom cheat sheet includes:

• The Houses of Normandy, Plantagenet, Lancaster, York, Tudor, Stuart, Hanover and Saxe-Coburg / Windsor
• Wives of Henry VIII
• Commonwealth Rulers

Downloads

The NaNoWriMo cheat sheet is a one-page reference sheet for NaNoWriMo 2011. Good luck with your books everyone!

Contents

The NaNoWriMo cheat sheet includes:

• Useful links
• A word count tracker
• Rules for effective writing (by George Orwell)
• Dramatic situations by Georges Polti
• The Hero's Journey
• Inspirational quotes from other authors

Downloads

The Linux Command Line cheat sheet is a one-page reference sheet for bash, nano, screen and a few other everyday tools on the Linux command line.

Contents

The Linux Command Line cheat sheet includes:

• Bash commands, shortcuts and variables
• IO Redirection (pipes etc)
• Directory and file operations
• File permissions and ownership
• Process management
• Options for the "ls" command
• Shortcuts for nano
• Shortcuts for screen

Downloads

The French cheat sheet, built with the help of wonderful people in the cheat sheets google group, contains a whole host of useful words and phrases to take with you on holiday

Contents

The French cheat sheet includes:

• Greetings and Pleasantries
• Days and Time
• Transport
• Buildings and Shops
• Pronouns
• Lost Items
• Directions
• Numbers
• Essential Phrases
• Signs
• Friends and Family
• Miscellaneous Words

Downloads

The Python cheat sheet is a one-page reference sheet for the Python programming language.

If you like the cheat sheets, and want to say thanks, please consider buying me something from my Amazon Wishlist. Thankyou very much to those who have already hunted it down and sent me something - I'm very grateful!

Downloads

The Python Cheat Sheet is released under a Creative Commons License (Attribution, Non-Commercial, Share Alike).

Please note: If you wish to link to a cheat sheet from elsewhere, please link to this page so others find all available versions, the license and the description.

sys Variables

Python has a variety of built-in variables which give information about the system on which it is running.

sys.argv

sys.argv contains command line arguments in a zero-based list.

os Variables

In a similar fashion to the "sys" variables, Python also has built in variables which give information about the operating system on which it is running. This section also lists the "registered" OS names.

Methods

Python, as you might expect, has a huge variety of standard methods for working with strings, lists, files and classes, and this section lists those with, where possible, compulsory arguments.

Indexes and Slices

Indexes and slices have been known to trip up plenty of new programmers, and occasionally experienced programmers new to Python. This section of the cheat sheet shows by example how indexes and slices work in Python.

Date and Time

These sections of the cheat sheet include the DateTime and Time methods, as well as the various Date Formatting options available for the strftime and strptime functions.

Thanks

This is the second cheat sheet created with the involvement of the Cheat Sheets Google Group, and the first to include twitter (@CheatSheets). Many thanks to Charly Walther and Dan Horning for their suggestions and feedback. Finally, thanks also to the 1017 people who requested this cheat sheet!

Translations

• Spanish / Español

The Subversion (SVN) cheat sheet is a one-page reference sheet for Subversion on the command line.

If you like the cheat sheets, and want to say thanks, please consider buying me something from my Amazon Wishlist. Thankyou very much to those who have already hunted it down and sent me something - I'm very grateful!

Downloads

• • PDF, 293Kb
• • PNG, 97Kb

The Subversion Cheat Sheet is released under a Creative Commons License (Attribution, Non-Commercial, Share Alike).

Please note: If you wish to link to a cheat sheet from elsewhere, please link to this page so others find all available versions, the license and the description.

Subversion Components

Subversion is made up of several different parts. In addition to the svn command line program most people are familiar with, there are also utilities like svnlook and svnadmin, a server (svnserve) and an apache module.

Subversion Protocols

Subversion clients can connect to subversion servers over a variety of different protocols, including HTTP and SSH.

Subversion Help

If you ever find yourself stuck, of unsure of how a command works (and this cheat sheet is unable to help), check out "svn help" for general Subversion help, or "svn help command" for help with a specific command. Please note that command line commands will be marked with "$" on this cheat sheet. Explanations will be on the following line and italicized.

Repository Administration

This section of the cheat sheet shows some of the basic, and most commonly used, repository commands, starting with how to create a new repository.

Getting Started

The first thing you are likely to want to do with a brand new repository is add some files to it. For this, you will need the import command. If you want to create a local copy (usually referred to as a working copy) of a repository, you will need to checkout. And if you want to grab any changes to the repository, you will need to run an update.

Adding, Deleting, Copying and Moving

These sections of the cheat sheet outline basic file and folder operations: Adding, Deleting, Copying and Moving.

Revert Changes

If you want to undo changes you have made to your working copy (i.e., change it back to the way it was when you last updated it), you can revert changes.

Logs and Blame

Log files are what make version control systems useful, giving you a complete history of changes to a repository. The log command will show you all the changes to a path, and the blame command will show you the changes to a path with more specific information.

Diffs and Merges

The diff command shows you the difference between two files, while the merge command allows you to apply the diff between two files to a third one.

Commit

Commit is the command you will use most often when working with SVN, by far. It is the command you run when you want to send what you've changed back to the repository. You should always add a message with your commit, explaining the changes you are making.

Miscellaneous Commands

This section of the cheat sheet lists some of the lesser used Subversion commands, including cleanup - a command to resursively remove locks and complete unfinished operations (very useful when things go wrong) and resolve (when you are working on a file, but another developer has changed the file at the same time, you will have a conflict - this command is to be used when the conflict has been resolved).

Item and Property Statuses

If you run the status command on a path, you will see a list of letters (and blank spaces) for each item in the path. Each of these letters has a specific meaning and tells you something about the file you are viewing. This section lists those letters and their meanings.

Property Commands

Items in a Subversion repository have properties specific to SVN, and these properties can be added to, edited or deleted. This section lists the commands you will need in order to be able to work with properties.

Argument Shortcuts

Finally, almost every Subversion command takes a selection of arguments, and many of these have shortcuts. If you want to commit changes to a folder, but don't want to commit changes to its contents, you could type svn commit --non-recursive "/path", but it's much quicker just to use the shortcut -N instead of --non-recursive.

Thanks

Much of the content on this cheat sheet is based on the excellent SVN Book, available at http://svnbook.red-bean.com/. This is the first cheat sheet created with the involvement of the Cheat Sheets Google Group. Many thanks to Alan Switzer and Randy Merrill for their suggestions and feedback. Finally, thanks also to the 210 people who requested this cheat sheet!

The Regular Expressions cheat sheet is a one-page reference sheet. It is a guide to patterns in regular expressions, and is not specific to any single language.

This is the second version of the Regular Expressions cheat sheet. The previous version can be found at http://www.addedbytes.com/cheat-sheets/regular-expressions-cheat-sheet-version-1/.

If you like the cheat sheets, and want to say thanks, please consider buying me something from my Amazon Wishlist. Thankyou very much to those who have already hunted it down and sent me something - I'm very grateful!

Downloads

The Regular Expressions Cheat Sheet is released under a Creative Commons License (Attribution, Non-Commercial, Share Alike).

Please note: If you wish to link to a cheat sheet from elsewhere, please link to this page so others find all available versions, the license and the description.

What's New?

There are a few small changes from the first version of the Regular Expressions Cheat Sheet (which you can still download if you prefer). The most obvious change may be that it now looks different. Hopefully it's now clearer and a little easier to find the information you're looking for.

About This Guide

I have included a little more detail in this document where I felt it would be helpful to those less familiar with regular expressions, to demonstrate some of the items on the sheet. Please feel free to let me know if any additions would be helpful.

Please also note that not everything on this sheet will work with every language that has regular expression support. Different languages use regular expressions in different ways, and in some, support is incomplete.

Anchors

Anchors in regular expressions refer to the start and end of things. This can be, for example, a string or word. These characters and symbols represent these anchors in regular expressions. For example, a pattern that matched a string that started with numbers might be the following, where "^" represents the start of the string.

^[0-9]+

Without the "^" symbol, the pattern would match any string with a digit in it.

Character Classes

Character Classes in regular expressions match a selection of characters at once. For example, "\d" will match any digit from 0 to 9 inclusive. "\w" will match letters and digits, and "\W" will match everything but letters and digits. A pattern to indentify letters, numbers or whitespace could be:

POSIX

POSIX is a relatively new addition to the regular expressions family, and is quite similar to the idea behind character classes, allowing you to use a shortcut to represent a particular group of characters.

Assertions

Almost everyone has some trouble with assertions at first. They are tricky to get to grips with, but once you are familiar with them, you will use them alarmingly often. They provide a way to say "I want to find out every word in this document with a q in it, as long as that q isn't followed by 'werty'".

The above code starts by matching non-whitespace characters ([^\s]*), then a q (err ... q). Then the parser reaches the lookahead assertion. This makes the q conditional. The q will only be matched if the assertion is true. In this case, the assertion is a negative assertion. It will be true if what it checks for is not found.

So, it checks the next few characters against the pattern it has (werty). If they are found, the assertion is false, and so it will "ignore" the q - it will not match. If it doesn't find "werty", the assertion is true, and the q is matched. It then carries on checking for non-whitespace characters.

Sample Patterns

Finally, there is a selection of sample patterns. These patterns are intended to allow you to look at how regular expressions might be used in day-to-day work, and the various ways you can use regular expressions. Please note, however, that they will not necessarily work in every language, as each has its own idiosyncracies and varying support for regular expressions.

Quantifiers

Quantifiers allow you to specify a part of a pattern that must be matched a certain number of times. For example, if you wanted to find out if a document contained between 10 and 20 (inclusive) of the letter "a" in a row, you could use this pattern:

Quantifier are "greedy" by default. So the quantifier "+", which means "one or more", will match as many items as possible. This can be a problem on occasion, so you can tell a quantifier to not be greedy (to be "lazy"), using a modifier. Consider the following code:

This will match text contained in quotation marks. However, you may have a string like this:

The pattern above will match the following from the above string:

It has been too greedy, matching as much text as it could.

The above pattern will also match any characters contained in quotation marks. The non-greedy version (note the "?" modifier) will match as little as possible of the string, so will match each item in quotation marks separately:

Special Characters

Regular expressions use symbols to represent certain things. However, that presents a problem if you want to detect a character in a string where that character is a symbol. A period (".") for example, in a regular expression, represents "any character except the new line character". If you want to find a period in a string, you can't just use "." as a pattern - it will match just about everything. So, you need to tell the parser to treat the period as a literal period rather than a special character. This you do with an escape character.

An escape character precedes the special character and tells the parser to ignore what follows. There are certain characters that will need to be escaped in the majority of patterns and languages, and you can find these characters listed at the bottom right of the cheat sheet.

The pattern to match a period is:

Other special characters in regular expressions represent unusual elements in text. New lines and tabs, for example, can be typed using a keyboard, but are likely to trip up programming languages. The special characters use the escape character as well, to tell the regular expression parser that the following character is to be treated as a special character rather than a normal letter or number.

String Replacement

String replacement is covered in more detail in the "Groups and Ranges" section below, however one small point to note is the existence of "passive" groups. These are groups that are ignored for the purposes of replacement. This is very useful when you want to match something that requires an "or" section, but don't want it in the replacement.

Groups and Ranges

Groups and ranges are very very useful. Ranges are perhaps the easiest place to begin. They allow you to specify a selection of characters to match. For example, if you wanted to see if a string contained hexadecimal characters (zero to nine and a to f), you would use this range:

If you wanted to see if a string did not contain the same, you would use a negative range, which in this case will match any character that isn't zero to nine or a to f.

Groups are essential to regular expressions, and are most often used when you want to use "or" in a pattern, or you want to reference part of a pattern later in the same pattern, or where using regular expression string replacement.

To use "or" is very simple - the following will match "ab" or "bc":

If you want to reference a previous group in a regular expression, you would use "\n", where "n" is the number of the group. You might need a pattern to match "aaa" or "bbb", followed by numbers, followed by the same 3 letters, and this would be done with groups, like so:

The above matches "aaa or bbb", and groups the match with the brackets. This is followed by a pattern for one or more numbers ("[0-9]+"), then finally "\1". The "\1" backreferences the first group, and looks for the same thing. It will match the matched text from the string, not the pattern, so "aaa123bbb" will not match the above pattern, as the "\1" will be looking for "aaa" to follow the numbers.

String replacement is one of the most useful tools of regular expressions. You can use "$n" to reference groups matched with the pattern when replacing text. Let's say you are want to make every instance of the word "wish" bold in a block of text. You would use a regular expression replacement function for this, which might look a little like this:

The pattern is first, and would be something like the following (you would need a few extra characters for this specific function.

This will find any instance of the word wish where it is preceded and followed by any non-alphanumeric character.

Your replacement can then be:

This replacement will replace the whole pattern matched above. We start with the first character matched above ($1) (the first non-alphanumeric one), otherwise we'll be deleting characters from the block of text. The same applies at the end ($3) of the match. In the middle, we add the HTML tags for bold text (though you should use CSS or <strong>, of course), with the second group matched in the pattern ($2).

Pattern Modifiers

Pattern modifiers are used in several languages, most notably Perl. These allow you to change how the parser works. For example, the "i" modifier will tell the parser to ignore case.

In Perl, regular expressions contain the same character at the beginning and end. This can be any character at all (often "/"), and is used like so:

Modifiers would be added at the end of this, like so:

Metacharacters

Finally, the last section of the cheat sheet lists the meta-characters. These are the characters that have special meaning in regular expressions, so if you want to use them literally, they must be escaped.

So, if you wanted to match test consisting of a bracket, you would need to use the following pattern:

Translations

• Italian / Italiano