- Use CamelCase. Capitalize the first letter, including all letters in an acronym, in a class, struct, protocol, or namespace name. Lower-case the first letter, including all letters in an acronym, in a variable or function name.
Right:
struct Data;
size_t bufferSize;
class HTMLDocument;
String mimeType();
Wrong:
struct data;
size_t buffer_size;
class HtmlDocument;
String MIMEType();
- Use full words, except in the rare case where an abbreviation would be more canonical and easier to understand.
Right:
size_t characterSize;
size_t length;
short tabIndex; // more canonical
Wrong:
size_t charSize;
size_t len;
short tabulationIndex; // bizarre
- Data members in C++ classes should be private. Static data members should be prefixed by "s_". Other data members should be prefixed by "m_".
Right:
class String {
public:
...
private:
short m_length;
};
Wrong:
class String {
public:
...
short length;
};
- Prefix Objective-C instance variables with "_".
Right:
@class String
...
short _length;
@end
Wrong:
@class String
...
short length;
@end
- Precede boolean values with words like "is" and "did".
Right:
bool isValid;
bool didSendData;
Wrong:
bool valid;
bool sentData;
- Precede setters with the word "set". Use bare words for getters. Setter and getter names should match the names of the variables being set/gotten.
Right:
void setCount(size_t); // sets m_count
size_t count(); // returns m_count
Wrong:
void setCount(size_t); // sets m_theCount
size_t getCount();
- Precede getters that return values through out arguments with the word "get".
Right:
void getInlineBoxAndOffset(InlineBox*&, int& caretOffset) const;
Wrong:
void inlineBoxAndOffset(InlineBox*&, int& caretOffset) const;
- Use descriptive verbs in function names.
Right:
bool convertToASCII(short*, size_t);
Wrong:
bool toASCII(short*, size_t);
- Leave meaningless variable names out of function declarations. A good rule of thumb is if the parameter type name contains the parameter name (without trailing numbers or pluralization), then the parameter name isn't needed. Usually, there should be a parameter name for bools, strings, and numerical types.
Right:
void setCount(size_t);
void doSomething(ScriptExecutionContext*);
Wrong:
void setCount(size_t count);
void doSomething(ScriptExecutionContext* context);
- Prefer enums to bools on function parameters if callers are likely to be
passing constants, since named constants are easier to read at the call
site. An exception to this rule is a setter function, where the name of the
function already makes clear what the boolean is.
Right:
doSomething(something, AllowFooBar);
paintTextWithShadows(context, ..., textStrokeWidth > 0, isHorizontal());
setResizable(false);
Wrong:
doSomething(something, false);
setResizable(NotResizable);
- Objective-C method names should follow the Cocoa naming guidelines —
they should read like a phrase and each piece of the selector should
start with a lowercase letter and use intercaps.
- Enum members should use InterCaps with an initial capital letter.
- Prefer const to #define. Prefer inline functions to macros.
- #defined constants should use all uppercase names with words separated by underscores.
- Macros that expand to function calls or other non-constant computation: these
should be named like functions, and should have parentheses at the end, even if
they take no arguments (with the exception of some special macros like ASSERT).
Note that usually it is preferable to use an inline function in such cases instead of a macro.
Right:
#define WBStopButtonTitle() \
NSLocalizedString(@"Stop", @"Stop button title")
Wrong:
#define WB_STOP_BUTTON_TITLE \
NSLocalizedString(@"Stop", @"Stop button title")
#define WBStopButtontitle \
NSLocalizedString(@"Stop", @"Stop button title")
- In header files in the WTF sub-library, however, it is acceptable
to use "using" declarations at the end of the file to import one
or more names in the WTF namespace into the global scope.
Right:
// wtf/Vector.h
namespace WTF {
} // namespace WTF
using WTF::Vector;
Wrong:
// wtf/Vector.h
namespace WTF {
} // namespace WTF
using namespace WTF;
Wrong:
// runtime/JSObject.h
namespace WTF {
} // namespace WTF
using WTF::PlacementNewAdopt;
- In C++ implementation files, do not use "using" declarations
of any kind to import names in the standard template library. Directly qualify
the names at the point they're used instead.
Right:
// HTMLBaseElement.cpp
namespace WebCore {
std::swap(a, b);
c = std::numeric_limits<int>::max()
} // namespace WebCore
Wrong:
// HTMLBaseElement.cpp
using std::swap;
namespace WebCore {
swap(a, b);
} // namespace WebCore
Wrong:
// HTMLBaseElement.cpp
using namespace std;
namespace WebCore {
swap(a, b);
} // namespace WebCore
- In implementation files, if a "using namespace" statement is
for a nested namespace whose parent namespace is defined in the file,
put the statement inside that namespace definition.
Right:
// HTMLBaseElement.cpp
namespace WebCore {
using namespace HTMLNames;
} // namespace WebCore
Wrong:
// HTMLBaseElement.cpp
using namespace WebCore::HTMLNames;
namespace WebCore {
} // namespace WebCore
- In implementation files, put all other "using" statements
at the beginning of the file, before any namespace definitions and
after any "include" statements.
Right:
// HTMLSelectElement.cpp
using namespace other;
namespace WebCore {
} // namespace WebCore
Wrong:
// HTMLSelectElement.cpp
namespace WebCore {
using namespace other;
} // namespace WebCore