您被迫遵循的最奇怪的编码标准规则是什么？

也许不是最古怪的一个，你会得到，但 我真的很讨厌在数据库表名前面加上“ tbl”

我 仇恨它时使用的多次返回是禁止的。

几乎所有的匈牙利命名法。

匈牙利命名法的问题在于，它常常被误解。最初的想法是给变量加上前缀，这样意思就清楚了。例如:

int appCount = 0; // Number of apples.
int pearCount = 0; // Number of pears.

但大多数人用它来确定类型。

int iAppleCount = 0; // Number of apples.
int iPearCount = 0;  // Number of pears.

这是令人困惑的，因为尽管两个数字都是整数，但是大家都知道，你不能把苹果和梨比较。

匈牙利命名法。

当您可以简单地使用 this 关键字时，请在全局变量前面使用 _ 或 m _。当你需要访问全局变量时。

任何与格式有关的东西(特别是“{”和其他块字符的位置)都是一个难以实施的问题。

即使在每个源文件检查时都有自动格式化，您也不能确定每个开发人员都会使用相同的格式化程序，使用相同的格式化规则集..。

然后你必须把这些文件合并回主干，这样你就自杀了;)

在 Delphi我们必须从

if something then
begin
...
end
else
begin
...
end;

到

if something then begin
...
end else begin
...
end;

在一个有150万行代码的项目中。想象一下在源代码控制、差异和合并中这是多么容易！当编译器宣布一个多余的结束时，它也会导致忘记开始和没有马上注意到它。

不能使用反射，因为经理声称它涉及太多的“魔术”。

我看到的最奇怪的一个是数据库表命名，其中表的前面是功能区域的 TLA，例如计算 ACC，然后是一个3位数字(覆盖默认排序) ，然后是表名。

另外，这也扩展到了列名。

ACC100 _ AccountCode

阅读一个查询是一场噩梦，它们是如此难以阅读。

上世纪80-90年代，我在一家使用 FORTRAN 语言的飞机模拟器公司工作。我们的 FORTRAN 编译器对变量名的限制是8个字符。该公司的编码标准保留了前三个匈牙利符号样式的信息。所以我们必须尝试创建只有5个字符的有意义的变量名！

这是一个编码标准，我没有遵循自己(陷入麻烦的其他事情，但从来没有这一点)。 我们有三个19英寸的显示器，所以我们可以有两个编辑器打开全屏，仍然可以访问桌面。 其他人不使用注释，而是使用有意义的名称。非常长的有意义的名字。我记得最长的是在80个字符的范围内。平均值在40 ~ 50之间。

你猜怎么着，他们没有准确地描述整件事。

您必须只使用五个字母表名，最后两个字符是为 IO保留的。

曾经在一个项目中工作，下划线是被禁止的。我是说完全禁止。因此，在 c # winforms 应用程序中，每当我们添加一个新的事件处理程序(例如一个按钮)时，我们必须将默认方法名从 buttonName _ Click ()重命名为其他名称，只是为了满足编写编码标准的人的自负。直到今天，我都不知道他为什么反对这个卑微的下划线

最奇怪的是在 Java 中必须使用类型限定的变量命名，以及数据库中列的类型。所以是 java.sql。ResultSet 必须被称为 tblClient 等。

我目前工作的地方不允许有三元操作员:

int value = (a < b) ? a : b;

因为不是每个人都能“明白”。如果您告诉我，“不要使用它，因为当结构变得太复杂时，我们必须重写它们”(嵌套的三元运算符，有人知道吗?)那我就明白了。但是当你告诉我一些开发商不理解他们... 嗯... 当然。

将 s _ 应用于被认为是控制系统的一部分的软件的“安全关键”的变量和方法。把这个规则和另一个关于把 m _ 放在成员变量前面的规则结合起来，你会得到一些荒谬的东西，比如“ s _ m _ la ()”，写起来非常烦人，而且在我看来不是很好读。最后，一些“安全专家”应该通过查看代码并使用这些“ s _”来确定一些东西，从而获得洞察力——在实践中，他们对 c + + 不太了解，所以除了报告我们标记为“安全关键”的标识符的数量之外，他们不能做太多其他的事情。一派胡言。

在 C + + 开发团队中，我们有一个有争议的第80个字符后面没有代码。一些人喜欢并强制执行代码审查; 另一些人鄙视。

此外，我们还有一个非常有争议的 C + + throw () ，throw (...)规范标准。被一些人使用的，被另一些人妖魔化的。双方阵营都引用讨论和专家的话来强调各自的立场。

通过 Sql Server 2000中的存储过程执行所有数据库查询:

select id, name from people

赞成程序的理由如下:

• 表演
• 保安
• 可维护性

我知道程序这个话题很有争议，所以请随意给我的答案打负分;)

如果我没记错的话，delphi IDE 默认缩进了两个空格。公司的大多数遗留代码有三个空格，由副总裁 IT 和首席执行官编写。有一天，所有的程序员都在讨论我们应该怎样做才能让我们的生活变得更简单，一个非常了解 Delphi 的承包商说: “嘿，IDE 默认为两个空格，有人对我们在新代码中这样做有意见吗?”我们所有人都看着对方，几乎认为这是一个毫无疑问的，并说我们同意。

两天后，副总裁和首席执行官发现我们将要进行这样一个危险的改变，可能会“引起问题”，并指示我们将使用三个缩进来处理所有事情，直到他们两个能够准确地评估这样一个改变的影响。现在我完全支持遵循标准，但是这些人认为 oo 编程创建的对象只有一个函数，这个函数具有执行操作所必需的 所有逻辑，而源代码控制将代码文件移动到另一个目录。

我在一个两家公司合并的地方工作。“主要的”一个有一个用 K & R C (即前 ANSI)编写的主要服务器。他们强迫 Java 团队(来自两个办公室——大概总共20个开发人员)使用这种格式，这种格式兴高采烈地忽略了“支撑辩论”的两大支柱，直接走向疯狂:

if ( x == y )
{
System.out.println("this is painful");
x = 0;
y++;
}

在我工作的地方，编码标准是一个巨大的卧槽: 奇怪的匈牙利命名法，前缀为“ g”的全局变量和成员为“ m”(所以有像 gsSome 变量这样的 gems) ，为每个函数添加“ ref string sError”，而不是抛出异常(这是一个巨大的 no!).

但是，杀手是在函数参数前面加上 I _ 作为输入参数，O _ 作为输出参数。

我现在在一个更好的地方工作:)

每1000行代码必须有165个单元测试(不一定是自动的)。大约每8行测试一次。

不用说，有些代码行很长，函数返回 这个指针以允许链接。

我的一个朋友在政府工作时遇到了这条规则。使用 + + (前或后)被完全禁止。原因是: 不同的编译器可能会有不同的解释。

所有 文件名必须小写..。

我们必须在每个 sql 语句之上放置一个注释

选择 USER _ ID 来自用户 名称 = : 名称;

你仍然需要在上面添加一个评论，说:

从 USERS 表中选择 USER _ ID，其中 name 等于输入的名称。

现在，当实际的注释比代码长，代码足够简单让二年级学生阅读，我真的不明白注释的意义... 但是，唉，我不得不回去，添加注释，就像这样的语句。

这是在一个主机上，用 cobol 编码。团队规模通常是4或5人左右，但这个规则时不时地会影响到这里的每一个人。

我最奇怪的一次是几年前签的合同。@ ZombieSheep 的奇怪之一是其中的一部分，但不是公司里最奇怪的一部分。

不，那家公司最奇怪的就是数据库命名方案。每个表都以大写字母命名，字与字之间有下划线。每个表都有一个前缀(通常是1-6个字符) ，通常是一个缩写或主表名的缩写。表中的每个字段也以相同的前缀作为前缀。因此，假设您有一个简单的模式，其中人们可以拥有猫或狗。就像这样:

PER_PERSON
PER_ID
PER_NameFirst
PER_NameLast
...
CAT_CAT
CAT_ID
CAT_Name
CAT_Breed
...
DOG_DOG
DOG_ID
DOG_Name
DOG_Breed
...
PERCD_PERSON_CAT_DOG (for the join data)
PERCD_ID
PERCD_PER_ID
PERCD_CAT_ID
PERCD_DOG_ID

也就是说，虽然一开始感觉很奇怪，但后来我渐渐喜欢上了。其背后的原因是有道理的(在你的大脑包裹它之后) ，因为前缀是为了提醒“推荐”(和强制!)构建联接时的表别名。前缀使大多数连接查询更容易编写，因为在字段之前显式引用表的情况非常罕见。

见鬼，过了一段时间，我们团队中的所有人(我们项目中的6个人)都能够在谈话中仅仅通过前缀来引用表了。当然，这是一种后天习得的品味，但是我越来越喜欢了。以至于当我有自由的时候，我仍然使用它。

我得到的结果类似于另一张海报中 SQL 表名的“ tbl”前缀。

在本例中，所有存储过程的前缀都是“ sp _”，尽管“ sp _”是 Microsoft 在 SQL Server 中用于系统级存储过程的前缀。他们的标准来自一个旧的非 MS 数据库，不会仅仅因为他们的标准可能会导致存储过程与系统存储过程发生冲突而产生不可预测的结果而改变。不，那样不合适。

让我抓狂的是人们在表的 ID 字段后面加上表的名称。只有身份证有什么问题？不管怎样，你都得化名... 为了神圣的爱！

想象一下，当您拥有名为 IDSEWEBLASTCUSTOMERACTION 和 IDSEEVENTLOGGER 的 id 字段时，您的 SQL 语句是什么样子的。

更改时不要删除任何代码。我们被告知要评论所有的变化。请记住，我们使用源代码控制。这项政策没有持续很长时间，因为开发人员对它以及它如何使代码不可读感到愤怒。

我有很多 愚蠢规则，但没有多少是我认为完全奇怪的。

最傻的一次是在90年代早期，我在美国宇航局工作。这是一项庞大的工作，有超过100名开发人员参与其中。编写编码标准的经验丰富的开发人员决定，每个源文件都应该以四个字母的首字母缩写开头，第一个字母必须代表负责该文件的小组。这可能是一个伟大的想法，为老 FORTRAN 77项目，他们习惯了。

但是，这是一个 艾达项目，具有良好的层次结构库结构，因此它毫无意义。每个目录中都充满了以同一个字母开头的文件，接着是3个无意义的字母，一个下划线，然后是重要文件名的一部分。所有的 Ada 软件包都必须从这个五个字符的疣开始。Ada“ use”子句也是不允许的(可以说在正常情况下是一件好事) ，所以这意味着任何对源文件 还有的非本地标识符的引用都必须包含这个无用的疣。也许应该有一个叛乱，但整个项目的工作人员都是初级程序员和大学新雇员(我是后者)。

典型的赋值语句(在 Ada 中已经很详细)最终看起来是这样的:

NABC_The_Package_Name.X := NABC_The_Package_Name.X +
CXYZ_Some_Other_Package_Name.Delta_X;

幸运的是，他们至少足够开明，允许我们超过80栏！尽管如此，这个设施疣还是被人们所痛恨，以至于它成为了每个人源文件顶部的样板代码，用 Ada“重命名”来去除疣。每个导入的(“ withed”)包都有一个重命名。像这样:

package Package_Name renames NABC_Package_Name;
package Some_Other_Package_Name renames CXYZ_Some_Other_Package_Name;
--// Repeated in this vein for an average of 10 lines or so

我们中间更有创意的做法是尝试 使用的疣，使一个真正明智的(或愚蠢的)包名称。(我知道你在想什么，但是不允许说脏话，你应该感到羞耻！真恶心)。例如，我在 Ccommon 代码组中，我需要制作一个与 Workstation 组接口的包。在与工作站的人进行了一次头脑风暴后，我们决定给我们的软件包命名，这样需要这两个软件包的人就必须写:

with CANT_Interface_Package;
with WONT_Interface_Package;

以前的工作:

• “正常”表以 T _ 开头
• “ System”表(通常是查找)以 TS _ 开头(除非因为某人那天不想查找而没有查找)
• 交叉引用表以 TSX _ 开头
• 所有字段名都以 F _ 开头

是的，没错。所有的字段，在每个表中。这样我们就可以告诉它是一个字段。

在2002-2004年，一家 vb6商店里有几个卧槽(我并不感到自豪，因为我饿了，需要吃点东西)。

最烦人的是，在子/函数的末尾将所有对象引用设置为空。这是为了“帮助”编译器引用计数。不管我为助教做了多少测试来证明这是不必要的，哦，不，这还是要做的，即使他没有任何证据支持他。最终我放弃了，大约一年后，我找到了一篇文章，解释为什么是裤子。我把这个拿给助教，心想“找到那个混蛋了!”.他说: “是的，我早就知道了，但是如果你开始改变标准的话，那么其他的开发人员，那些每天和他一起工作的人就会把事情搞砸。”。去死吧。

同一家店里的其他人。

• 永远不要删除代码，总是注释它 (即使我们使用 源头控制)。
• 表名的前缀 没有任何意义，但是 必须在新桌子上强制执行。
• 在所有对象前面加上 o _ (lo _ 对于过程级引用，mo _ For module，go _ for global). 对于一个项目来说毫无意义 其他变量都是 对象引用。

大部分时间我都在写 c + + (只有 c + + 开发人员，所以制定了自己的标准，并严格执行!)偶尔用一下 vb 否则我也坚持不了多久。

文件的创建者(不需要输入任何代码)必须在文件中输入他们的名字。因此，如果您创建存根或占位符，您将永远“拥有”它们。

实际编写代码的人不会加上他的名字; 我们有源代码控制，这样我们就会知道，总是责怪谁。

我完全不同意这一点，但我被迫遵循它:

“所有 HTML 链接将总是下划线。”< br/> < br/> 不久前，我解释了为什么我不同意我的 博客。

注意: 即使是 Stackoverflow，当你将鼠标移动到链接上时，它也只会强调链接。

没有单个字符变量名——即使对于像 i 这样的简单迭代器，也必须使用 ii 或其他名称。我觉得这很蠢。

另一个-也许是最疯狂的，但也许不是一个编码标准..。

不允许使用 STL。这是在2007/2008年。我发现那些胡言乱语后不久就离开了那里。显然，有些白痴认为没有“标准”(就像15年前一样... ...)我想他们错过了关于仍然是 C + + 标准的备忘录... ..。

对于几乎所有的方法，都使用愚蠢的 COM HResults T 作为返回类型——即使它们不是 COM。太可笑了。因此，现在我们不再返回一些枚举类型或指示结果的有用值等，我们必须查找每个方法的上下文中的 S _ OK 或 E _ FAIL 或其他含义。再说一次，我很快就离开了那里。

每个开头和结尾的大括号都是 需要，用来注释:

public void HelloWorld(string name)
{


if(name == "Joe")
{
Console.WriteLine("Hey, Joe!");
} //if(name == "Joe")
else
{
Console.WriteLine("Hello, " + name);
} //if(name == "Joe")
} //public void HelloWorld(string name)

这就是为什么我要编写我的第一个 VisualStudio 插件来实现自动化的原因。

因为我一直是自由职业者/自由职业者/项目负责人，我从来没有进入别人的标准，所有的标准都是我的决定。但是，我最近在15岁的时候发现了一个有趣的“编码标准文档”:

所有函数必须命名为“ ProjectName _ FunctionName” 。

有人知道程序 PHP 吗？那时候还没有困难的 PHP 面向对象编程，但是仍然存在。如果我想使用从一个项目到另一个项目的代码，我必须重写所有的引用，等等。

我可以使用类似于“ package _ FunctionName”的东西。

完全没用的数据库命名约定。 每个表名都必须以一个数字开头。数字显示表中的数据类型。

• 0: 到处使用的数据
• 1: 仅由某个模块使用的数据
• 2: 查找表
• 3: 日历，聊天和邮件
• 4: 伐木

如果只知道表名的第一个字母，就很难找到表。 另外，由于这是一个 mssql 数据库，因此我们必须在所有表名的周围放置方括号。

-- doesn't work
select * from 0examples;


-- does work
select * from [0examples];

在我使用 COBOL 的时候，我们必须使用三个星号作为注释(COBOL 在第7列中只需要一个星号)。我们甚至有一个预编译器来检查这一点，如果你使用任何东西，但三个星号不会编译你的程序。

一半的团队支持四空间缩进，另一半支持两空间缩进。

正如你可以猜到的，编码标准强制要求三个，以便“平等地冒犯所有人”(直接引用)。

我实现并修改了一个开源的 asp 经典购物车(主要是一长串 dailyWTF 候选者) ，它以小写 p 开始每个变量。 例如，pTax _ amount 或 pFirst _ Name。

对此没有任何解释，但我在他们的一个论坛上读到，这是为了避免使用像 State 这样的保留词——你可以用 pState 代替。 他们还会随机附加温度。比如 rsTemp 和 connTemp。我想，与永久记录集和数据库连接不同。

我被告知，旧代码应该被注释掉而不是被删除; 以防我们需要引用旧代码(是的，代码在源代码控制中...)。在做出重大改变之前，这看起来并没有那么糟糕。然后它就变成了一场噩梦，整个代码段都被删除了。

反向压痕，例如:

    for(int i = 0; i < 10; i++)
{
myFunc();
}

以及:

    if(something)
{
// do A
}
else
{
// do B
}

禁忌:

while (true) {

允许:

for (;;) {

在我的 C + + 时代，我们不允许使用 = = ，> = ，< = ，& & 等等，这里有宏..。

if (bob EQ 7 AND alice LEQ 10)
{
// blah
}

这显然是为了处理“旧的条件错误意外赋值”，但我们 还有有“把常量放在变量之前”的规则，所以

if (NULL EQ ptr); //ok
if (ptr EQ NULL); //not ok

只要记住，我听说过的最简单的编码标准是“编写代码，就好像下一个维护人员是一个知道你住在哪里的恶毒的精神病患者。”

为几乎所有方法编写包含无意义信息的方法注释。

不允许方法有多个退出点。

所有变量、枚举、结构甚至类的匈牙利命名法，例如 iMyInt、 tagMySturture、 eMyEnum 和 CMyClass。

我曾经在 伟大的 VB King的暴政下工作过。

VB King是 MS Excel 和 VBA 以及数据库(因此他的姓氏是: 他用 Excel，而开发人员用编译器，在数据库上挑战他可能会对你的职业生涯产生不利影响..。)的纯粹主人。

当然，他的 无边无际技能给了他一个关于开发问题和项目管理解决方案的 独一无二愿景: 虽然严格意义上不完全是编码标准，但 VB King经常有关于“编码标准”和“最佳实践”的新想法，他试图强加给我们(经常成功)。例如:

• 所有的 C/C + + 数组都应该从索引1开始，而不是0。事实上，使用0作为数组的第一个索引已经过时了，并且已经被 VisualBasic6有见地的数组索引管理所取代。

• 所有函数都将返回错误代码: 在 VB6中没有异常，那么我们为什么需要它们呢？(例如在 C + + 中)

• 由于“所有函数都应返回错误代码”对于返回有意义类型的函数来说并不实用，所有函数都应该有一个错误代码作为第一个[ in/out ]参数。

• 我们所有的代码将检查错误代码(这导致了我职业生涯中见过的最糟糕的 VBScript if-indent 情况... ... 当然，由于从未处理过“ else”子句，所以实际上没有发现错误，直到为时已晚)。

• 由于我们使用的是 C + +/COM，因此从今天开始，我们将用 VisualBasic 编写所有 DOM 实用程序函数。

• ASP115错误是邪恶的。为此，我们将在 VBScript/ASP 代码中使用 On Error Resume Next 来避免这些错误。

• XSL-T 是一种面向对象的语言。使用继承来解决您的问题(有一天我的下巴差点被吓破了)。

• 不使用异常，因此应该删除异常。出于这个原因，我们将取消复选框，在异常解除(一位专家花了几天时间才找到所有这些内存泄漏的原因，当他发现他们自愿忽略(并隐藏)他关于再次检查选项的技术说明时，他几乎要发狂了)的情况下请求析构函数调用。

• 捕获 COM 模块的 COM 接口中的所有异常，并静默地处置它们(这样一来，不是崩溃，而是一个模块只会显得更快... 闪亮！由于我们使用了上面描述的超级错误处理，我们甚至花了一些时间来理解到底发生了什么... 你不可能同时拥有速度和正确的结果，不是吗？)。

• 从今天开始，我们的代码库将分为四个分支。我们将管理他们的同步和手工集成所有的错误修正/发展。

除了 C/C + + 数组，实用函数和 作为面向对象语言的 XSL-T之外，所有的都被实施了，尽管我们提出了抗议。当然，随着时间的推移，一些被发现，嗯哼，破碎，并完全放弃。

当然，VB King的信誉从未因此受损: 在高层管理人员中，他仍然是一位“顶级枪手”技术专家..。

这产生了一些有趣的副作用，正如你可以看到的链接 你曾经遇到过的源代码中最好的注释是什么

我们在做一个 C + + 项目，团队领导是一个叫帕斯卡的家伙。

所以我们有一个编码标准的 include 文件来重新定义那些讨厌的 C 和 C + + 语法:

#define BEGIN {
#define END }

等等，还有呢！

#define ENDIF }
#define CASE switch

过了这么长时间，很难记起来了。

这使得原本完全可读的 C + + 代码变得难以辨认，除了团队领导。

我们还必须使用反向匈牙利命名法。

MyClass *class_pt  // pt = pointer to type


UINT32 maxHops_u   // u = uint32

不过奇怪的是，我渐渐喜欢上了这个。

后缀 _ to 成员变量。

int numberofCycles_;

这是在 C + + 的一个开源项目中，由几个开发人员完成的。主要的副作用是直到名称结束时才知道变量具有类作用域。我以前没怎么想过这个问题，但显然是想反了。

一个没有人提到的问题是，被迫为无脑的 getter 和 setter 类编写单元测试。

队伍大约有十二人。对于 C # 方法，我们必须在每个函数之前放置一个巨大的 XML 格式化函数。我不太记得具体的格式，但是它涉及到嵌套在三到五个层次上的 XML 标记。下面是记忆中这条评论的一个草图。

/// <comment>
/// </comment>
/// <table>
///    <thead>
///       <tcolumns>
///          <column>Date</column>
///          <column>Modified By</column>
///          <column>Comment</column>
///       </tcolumns>
///    </thead>
///    <rows>
///       <row>
///          <column>10/10/2006</column>
///          <column>Fred</column>
///          <column>Created function</column>
///       </row>
///    </rows>
/// <parameters>

我得停下来。

不利因素很多。

• 文件主要由注释组成。
• 我们没有使用我们的版本控制系统来跟踪对文件的更改。
• 编写许多小函数会影响可读性。
• 很多滚动条。
• 有些人没有更新评论。

我使用了一个代码片段(Emacs YAS)将这段代码添加到我的方法中。

我不允许使用 this->在我们的 c + + 代码中引用本地变量..。

我们必须按字母顺序对类中的所有函数进行排序，使它们“更容易找到”。 不用担心，这里有一个下降。这是太多的点击。

(同一个技术领导写了一个应用程序来删除我们源代码中的所有注释)。

我曾经不得不拼写出所有的首字母缩略词，甚至是像 OpenGL 这样的行业标准。像 glu 这样的变量名称并不好，但是我们必须使用 GraphicsLibraryUtility。

使用通用编号标识符名称

在我目前的工作中，我们有两条真正刻薄的规则:

规则1: 每次在数据库表中创建新字段时，都必须添加额外的保留字段以备将来使用。这些保留字段是编号的(因为没有人知道它们将来会保存哪些数据)下次我们需要一个新字段时，我们首先查找一个未使用的保留字段。

因此，我们最终使用包含客户电子邮件地址的 customer.reserve_field_14。

有一天，我们的老板想引进 预订餐桌，但幸运的是，我们可以说服他不要这样做。

规则2: 我们的一个产品是用 VB6编写的，VB6对不同标识符名称的总数有一个限制，由于代码非常大，我们经常遇到这个限制。作为一种“解决方案”，所有局部变量名都要编号:

• Lvarlong1
• Lvarlong2
• Lvarstr1
• ...

虽然这有效地规避了标识符限制，但是这两个规则结合起来就产生了像下面这样漂亮的代码:

...


If Lvarbool1 Then
Lvarbool2 = True
End If


If Lvarbool2 Or Lvarstr1 <> Lvarstr5 Then
db.Execute("DELETE FROM customer WHERE " _
& "reserve_field_12 = '" & Lvarstr1 & "'")
End If


...

你可以想象修复旧的或者别人的代码有多难。

最新更新: 现在我们也对私人会员使用“预约程序”:

Private Sub LSub1(Lvarlong1 As Long, Lvarstr1 As String)
If Lvarlong1 >= 0 Then
Lvarbool1 = LFunc1(Lvarstr1)
Else
Lvarbool1 = LFunc6()
End If
If Lvarbool1 Then
LSub4 Lvarstr1
End If
End Sub

编辑: 看起来这个代码模式越来越流行了。看看这个 每日卧槽文章了解更多: 散光:)

在 C + + 中，我们必须为每个类写出编译器应该为我们写出的所有东西(缺省构造函数、析构函数、复制建构子、复制赋值操作符)。看来写标准的人对语言不是很自信。

也许我遇到过的最令人沮丧的情况之一是，人们坚持在存储过程前面加上前缀“ sp _”。

如果你不知道为什么这是一件坏事，看看这个博客条目 这里！

简而言之，如果 SQLServer 正在寻找带 SP _ 前缀的存储过程，它将首先检查主数据库(除非 SP 实际位于主数据库中，否则它不会找到主数据库)。假设它不在主数据库中，SQLServer 假设 SP 不在缓存中，因此重新编译它。

这听起来可能是一件小事，但是它在大容量或繁忙的数据库服务器环境中会产生影响！

我经历过的最糟糕的事情就是代码检查。出于某种原因，尽管我们已经使用了 vcs 的 diff 工具来查看发生了什么变化，但是当您希望检查代码时，您必须在文件/函数中包含一些注释块，如下所示:

/*********...80charswide...***
* START INSPECT
*/


some changed code...


/*
* END INSPECT
*********...80charswide...****/

在检查之后，您必须返回并在提交. ugh 之前删除所有这些注释块。

在我公司的一个大型团队中，我们几乎只使用 C + + ，不允许传递非常量引用。

如果要将参数修改为函数，则必须通过指针传递参数。

我们内部对于优点(更容易识别可以修改变量的函数调用)和缺点(荒谬; 当你需要一个参数时，必须处理可能的 NULL 指针)有一年一次的争论。

“编写编译器的家伙可能比你聪明得多，所以不要尝试聪明的东西”，这是一个指南文档说的(不完全是字面上的意思)。

插入换行符
(//--------------------------------------------------------------------------------)
在 c # 项目中的方法之间。

最奇怪的一次，也是我花了很长时间才推翻的一次，是我们公司的老板要求我们的新产品只能是 IE。如果它可以在 FireFox 上工作，那没问题，但它必须只能是 IE。

这听起来可能不太奇怪，除了一个小瑕疵。所有的软件都是定制的服务器软件包，运行在 Linux 上，我们的客户购买的所有客户机都是 Linux。如果不想弄清楚如何让 Wine (在那些日子里，非常不可靠)在所有这些盒子上运行，看看我们是否能让 IE 运行并训练他们的管理员如何调试 Wine 问题，就根本不可能满足所有者的要求。问题是他在做网页设计，根本不知道如何使网站与 FireFox 兼容。

知道我们公司破产了，你可能不会感到吃惊。

被迫在一个方法的末尾只有一个 return 语句，并使代码降到这个值。

也不能在开关中重用 case 语句并让它通过; 我必须编写一个复杂的脚本，对开关执行某种循环，以正确的顺序处理这两种情况。

最后，当我开始使用 C 语言时，我发现在方法的顶部声明变量非常奇怪，而且非常讨厌它。我在 C + + 中花了好几年的时间，想在哪里声明就在哪里声明; 除非出于优化的原因，我现在在一个方法的顶部声明所有的方法变量，并详细说明它们都做什么——这使得维护更加容易。

我公司的所有文档都是版本控制的，目前为止一切正常。

但是对于每个单独的文件，在第一次提交到 CVS 时，必须立即向其添加两个标记: CRE(用于 CREation)和 DEV001(用于第一个 DEVeldevelopment 周期)。好像文件本身的第一个版本还不够似的。

幸运的是，在那之后，这个过程变得更加合理了。

以 dbo _ 为表的前缀

是的，与 dbo.dbo _ tablename 一样。

我在 VB 工作。NET 商店三年前，那里的“技术领导”规定，所有接受引用类型参数(即，一个对象)的方法必须使用 拜，裁判而不是 作者: Val。我觉得这特别奇怪，因为他们在我的采访中问我 ByVal/ByRef-what’s-the-different 问题，我解释了它对值类型和引用类型的作用。

他对这种做法的解释是: “一些新的、缺乏经验的开发人员可能会感到困惑。”

当时，我是最近才被雇佣的，这是我的第一份永久工作。NET 工作。我没有被它搞混。

我专业使用的第一种语言是4D。它支持前缀为 < > 的进程间变量、没有前缀的进程变量和以 $开头的局部变量。编译器/解释器使用所有这些前缀(或缺少前缀)来确定变量的作用域。

真正奇怪的编码标准是某种匈牙利命名法。问题是，不能根据变量的类型来命名变量，而是必须根据它们的作用域给它们加上前缀。

变量的范围由它们的前缀决定，必须在前缀中加入冗余信息！

我不敢问负责制定标准的人为什么要这样。

几年前，在一份 C 级的工作中，我遇到了两条我非常讨厌的规则:

1. “每个文件一个模块”，其中“模块”被定义为一个 C 函数。

2. 函数局部变量只允许在函数的顶部，所以这种事情是非法的:

if (test)
{
int i;
...
}

我非常讨厌别人不用变数命名原则。在我工作的地方，首席开发人员(我取代了他)不知道他是想使用 camelCase 还是 way _ over _ used _ underscore。就我个人而言，我讨厌下划线，骆驼大小写更容易阅读，但是只要保持一个标准就没有关系。

PHP 在这方面尤其糟糕，看看 mysql _ numrows，它将两者合并而不使用大写。

我的一个朋友——我们叫他 CodeMonkey ——大学毕业后找到了他的第一份工作(很多年前) ，做 COBOL 的内部开发。他的第一个程序因为“不符合我们的标准”而被拒绝，因为它使用了... ... [颤抖! ]嵌套 IF 语句

编码标准禁止使用嵌套 IF 语句

现在，CodeMonkey 并不害羞，而且对自己的能力很有信心，所以他坚持问每个人为什么会有这样的规则存在。大多数人声称他们不知道，一些人编造了关于“可读性”的东西，最后一个人记起了最初的原因: 他们使用的 COBOL 编译器的第一个版本有一个 bug，没有正确处理嵌套的 IF 语句。

当然，这个编译器错误已经修复了至少十年，但是 没有人挑战这些标准

CodeMonkey 成功地改变了标准——最终！

不完全是一个编码标准，但在1998年，我在一家禁止使用 C + + 的公司工作。这是因为面向对象被认为过于复杂，软件工程师无法掌握。

在我们的 C 代码中，我们被要求在所有分号前加一个空格

int someInt = 5 ;

我一直找不到这样做的理由，但是过了一段时间，我确实开始喜欢上它了。

在每个方法的末尾添加一个80个字符的注释，这样很容易找到方法的末尾。像这样:

void doSomething()
{
}
//----------------------------------------------------------------------------

理由是:

• 有些用户不使用具有代码折叠功能的 IDE (好的，我会给他们这个功能)。
• 由于人们可能不遵循关于缩进和括号放置的其他编码标准，因此很难找到函数的结尾，所以方法之间的空间并不清楚。(不相关; 如果您需要添加这个，因为人们不遵循您的编码标准，那么他们为什么要遵循这个标准呢?)

(http://en.wikipedia.org/wiki/SCORM)

我一直在研究用 mysql 关键字命名表列。它需要在您编写的每个查询中转义愚蠢的列名。

SELECT this, that, `key` FROM sometable WHERE such AND suchmore;

太可怕了。

在我目前工作的地方，官方编码标准规定最大行长为80个字符。理性的做法是允许对代码的硬拷贝进行格式化。不用说，这导致了非常奇怪的代码布局。我一直致力于消除这个标准，主要是通过这样一个论点: “你最后一次制作代码的硬拷贝是什么时候?”？现在的可读性和在80列 DMP 上打印的机会？

斯基兹

虽然这不是在工作，我们有一个庞大的项目，在大学的一个班级。需求之一是在我们的应用程序中注释 每个代码行——不管它做了什么... ... 每一行都必须是特定的，例如。

int x=0; //declare variable x and assign it to 0

我们不能这么做:

int x, y, z = 0; //declare and assign to 0

因为它不够详细，甚至没有遵循强加给我们的命名惯例。

不用说，我们花了几个小时回顾了代码..。

(可能只有在英国才有趣)

我工作过的一家保险公司想要一个组合“ P”或“ L”来表示范围，用匈牙利语表示类型，用于所有财产。

好处是我们有一个叫 PintMaster 的地方，让我们都想喝一杯。

在英国的一家大银行，我被任命为一个新的.NET 系统的设计权威。

他们的规则规定，数据库表最多只能有8个字符，并以项目代码(5位数字代码)作为前缀。

他们在 Windows 项目 叹气上强制执行旧的 DB2规则

每个逻辑行只能声明一个变量。[基本原理: 每行多个声明会导致代码行计数不准确。]

在我的第一份工作中，所有的 C 程序，无论多么简单或复杂，只有四个函数。您有 main 函数，它依次调用其他三个函数。我不记得他们的名字了，但是他们大概是开始()、中间()和结束()。Start ()打开的文件和数据库连接，end ()关闭它们，mid ()执行 其他的一切。毋庸置疑，mid ()是一个 非常长函数。

为了让事情变得更好，所有的变量都必须是全局的。

我对这份工作最自豪的记忆之一，就是参与了导致这些标准遭到破坏的全面反抗。

不是匈牙利人。

好吧，你认为这很糟糕为什么? 因为他们认为这是匈牙利语:

int foo;
int *pFoo;
int **hFoo;

现在，任何老派的 Mac 程序员都会记得处理 Handles 和 Ptrs。以上是区分它们的最简单的方法——苹果的样本代码中充满了这样的代码，而且苹果也不是匈牙利人的温床。所以当我不得不写一些老式的 Mac 代码的时候，我自然而然地就写了，并且因为是匈牙利语而被否决了。

但是没有人能够提出一个替代的命名方案来保持三个变量以不同的方式引用同一数据的清晰性，所以我按原样检查了它。

我不得不拼写和语法检查我的评论。它们必须是完整的句子，大写正确，并以句号结尾。

1987年左右，我在一家公司找到了一份工作，公司雇佣了我，因为我是少数几个知道如何使用《启示录》的人之一。启示录，如果你从来没有听说过它，本质上是一个基于 PC 的实现拣选操作系统——如果你从来没有听说过它，它的名字得到了它的发明者，令人难以置信的名字迪克拣选。关于选择操作系统可以说很多，大多数都是好的。许多超小型供应商(至少是 Prime 和 MIPS)使用 Pick，或者他们自己的自定义实现。

这家公司是一个主要的商店，他们的内部系统，他们使用的信息。(不，那其实是它的名字: 它是 Prime 对 Pick 的实现。)他们与政府签订了建立一个基于 PC 的系统的合同，并且在启示录项目中投入了大约一年的时间，直到那个做所有工作的家伙，同时也是他们的管理信息系统主管，决定他不能再同时做这两份工作，于是雇佣了我。

无论如何，他已经为他们的基于 Prime 的软件建立了一些编码标准，其中许多源于两个基本条件: 1)使用80栏的哑终端，2)事实上，由于 Prime 没有可视化编辑器，他已经编写了自己的。由于拣选代码的神奇可移植性，他将自己的编辑器引入到《启示录》中，并使用它在 PC 上构建了整个项目。

当然，启示录是基于 PC 的，有一个非常好的全屏编辑器，并且在您浏览第80栏时没有反对。然而，在我到那里的头几个月，他坚持要我用他的编辑和他的标准。

因此，第一个标准是每行代码都必须注释。每一句台词。没有例外。他的理由是，即使注释与代码中写的内容完全一致，但必须注释意味着至少要考虑两次这一行。此外，正如他高兴地指出的那样，他还向编辑器添加了一条命令，对每行代码进行格式化，以便您可以放置行尾注释。

哦，是的。当您注释每一行代码时，它使用的是 终点站注释。简而言之，每行的前64个字符是代码，然后是分号，然后有15个字符来描述64个字符的功能。简而言之，我们使用汇编语言约定来格式化我们的 Pick/Basic 代码。这导致了这样的结果:

EVENT.LIST[DATE.INDEX][-1] = _         ;ADD THE MOST RECENT EVENT
EVENTS[LEN(EVENTS)]                 ;TO THE END OF EVENT LIST

(实际上，20年后我终于忘记了 R/Basic 的行连续语法，所以它看起来可能有所不同。但你明白我的意思。)

此外，无论何时你必须插入多行注释，规则是你使用一个花盒:

************************************************************************
**  IN CASE YOU NEVER HEARD OF ONE, OR COULDN'T GUESS FROM ITS NAME,  **
**  THIS IS A FLOWER BOX.                                             **
************************************************************************

是的，每一行都需要那些结束星号。毕竟，如果您使用他的编辑器，那么插入一个花盒只是一个简单的编辑器命令。

让他妥协让我使用《启示录》的内置编辑器真是一场艰苦的战斗。一开始他很坚持，只是因为这是规矩。当我反对的时候，a)我已经知道启示录的编辑器 b)它实质上比他的编辑器功能更多 c)其他的启示录开发者会有同样的观点，他反驳说如果我不在他的编辑器上训练，我将永远不能在 Prime 代码库上工作，我们都知道，只要地狱仍然不冻结，这是不会发生的。最后他屈服了。

但是编码标准是最后一个被淘汰的。尤其是那些关于花盒的评论，简直就是愚蠢的浪费时间，他对这些评论穷追猛打，说如果我使用正确的编辑器来维护这些评论就会非常容易。(整件事变得相当消极主动。)最后，我悄悄地让步了，从那时起，我带给代码审查的所有代码都有了他珍贵的花盒注释。

工作几个月后的某一天，我已经证明了自己的能力(尤其是与我在那里工作时经过那间办公室的众多程序员相比) ，他在我工作的时候看着我的肩膀，他注意到我没有使用花盒评论。哦，我说，我写了一个源代码格式化程序，当我打印出来的时候，它可以把我的注释转换成你的风格。这比在编辑器中维护它们要容易。他张开嘴，想了一会儿，闭上嘴，走开了，我们再也没有谈论过编码标准。从那以后，我们的工作都变得轻松了。

在爪哇，当承包某个不能透露姓名的地方时，接口被禁止。逻辑？负责人找不到 Eclipse 的实现类..。

还有被禁止的匿名内部课程，因为负责人不知道这些课程是什么。这使得实现 Swing GUI 变得非常有趣。

最糟糕的是我仍然在一个无名的地方赚钱，没有标准。每个计划都是新的冒险。

幸运的是，另一个承包商和我正在慢慢地培训真正的员工，并强迫一些混乱的结构。

这让我想起了我工作过的一个地方，亚利桑那州交通部。

有一个项目经理不理解基于对象的编程(也不想理解它)

(说真的——她实际上花了很多时间来检查我们在 Visual SourceSafe 上签入的代码，以确保我们没有违反规则)。

考虑到 Visual Basic 4刚刚发布(大约是12年前) ，并考虑到我们在 VB4 使用对象来描述形式中构建的 Windows 表单应用程序，这使得开发变得... ... 复杂。

我的一个朋友实际上试图通过将他的“对象代码”封装在虚拟的“表单”中来解决这个问题，她最终发现他只是(* 喘气 *)隐藏了他的对象！

不用说，我只在那里呆了3个月。

天啊，我不喜欢那个女人的想法。

这不是一个编码标准问题，但肯定是一个限制性思维的故事。我们在不少于7周的时间里完成了一个为期4周的短期项目。该计划是松散地基于估计一个特征列表。开发过程包括疯狂的编码。在事后分析期间，我建议使用里程碑并将特性请求分解为任务。令人难以置信的是，我的主管驳回了我的想法，说因为这是一个如此短的项目，我们不需要使用里程碑或任务，并要求其他建议。房间里一片寂静。

语言: Java，C + + ，HTML 团队规模: 两个团队，共10名工程师 它给你和你的团队带来了什么不良影响: 我感觉自己被困在呆伯特卡通里了。

给我们的表输入数字，比如 tbl47 _ [某个名字]

在我上一份工作中，我的上司总是执行墨菲定律:

“任何可能出错的事情都会出错。”

我想这是因为我们没有偷懒，在代码中做一些快速修复之类的事情。现在我脑子里一直有这句话。

我对编码标准的抱怨与我在这里看到的一些令人发指的东西相比是相当温和的，但是这里有:

我在一个项目中，一些开发人员坚持使用我所见过的最奇特的缩进形式:

if (condition)
{
x++;
printf("Hello condition!\n");
}
else
{
y++;
}

我们正在为一个嵌入式环境开发一个非常烂的调试器。实际上，printf ()、 hexdump ()和 mapfile 是首选的调试方法。这当然意味着禁止使用 static，所有全局变量和函数必须采用 modulename_variablename的形式。

使用警告检入代码是被禁止的(这并不是一件坏事) ，但是编译器会对任何常量条件发出警告。因此，禁止使用 do { something(); } while(0)的旧的宏/语句技巧。

最后，在枚举器列表或初始值设定项后面留下逗号被认为是懒惰的，因此是禁止的:

enum debuglevel
{
NONE,
FATAL,
WARNING,
VERBOSE,   // Naughty, naughty!
};

就像我说的，相当温顺。但作为一名“ C 程序员的十诫”的追随者，我发现这种非传统的支撑风格绝对令人恼火。

一个外部编写的 C 语言编码标准，其规则是“不依赖于内置的操作符优先级，总是使用括号”

很公平，明显的意图是禁止:

a = 3 + 6 * 2;

赞成:

a = 3 + (6 * 2);

问题是，这是由一个遵循 C 语法规则“ =’,’= =’,’”的工具强制执行的和数组访问是运算符。所以代码是这样的:

a[i].x += b[i].y + d - 7;

必须写成:

((a[i]).x) += (((b[i]).y + d) - 7);

我以前的老板坚持我们使用常量而不是枚举，但是从来没有给出理由，在所有的场景中使用枚举更有意义。

不过，更好的做法是坚持所有表名都是单数，然后让类也成为代码单数。但是它们不仅表示对象，比如用户或组，它们还表示表，并包含该表的所有 CRUD 和许多其他操作。等等，还有呢！它们还必须包含一个公开可见的名称/值集合，以便您可以通过索引器按列名获取属性，以防您添加了一个新列但不想添加新属性。还有许多其他的“必须做的事情”，这些事情不仅没有意义，而且对代码的性能也有很大的影响。我可以试着把它们全部指出来，但是代码本身就说明了一切，遗憾的是，这几乎是我刚刚从一个旧的归档文件夹中提取出来的 User 类的一个精确副本:

public class Record
{
private string tablename;
private Database database;


public NameValueCollection Fields;


public Record(string TableName) : this(TableName, null) { }
public Record(string TableName, Database db)
{
tablename = TableName;
database = db;
}


public string TableName
{
get { return tablename; }
}


public ulong ID
{
get { return GetULong("ID"); }
set { Fields["ID"] = value.ToString(); }


}


public virtual ulong GetULong(string field)
{
try { return ulong.Parse(this[field]); }
catch(Exception) { return 0; }
}


public virtual bool Change()
{
InitializeDB(); // opens the connection
// loop over the Fields object and build an update query
DisposeDB(); // closes the connection
// return the status
}


public virtual bool Create()
{
// works almost just like the Change method
}


public virtual bool Read()
{
InitializeDB(); // opens the connection
// use the value of the ID property to build a select query
// populate the Fields collection with the columns/values if the read was successful
DisposeDB(); // closes the connection
// return the status
}
}


public class User
{
public User() : base("User") { }
public User(Database db) : base("User", db) { }


public string Username
{
get { return Fields["Username"]; }
set
{
Fields["Username"] = value.ToString(); // yes, there really is a redundant ToString call
}
}
}

对不起，如果这个双职位，第一次我可能不是人类，或者也许该网站只是有一个限制，如何糟糕的代码可以张贴

用 _ 标记私有变量，以确保我们正在处理类中的私有变量。然后使用 php 的神奇方法 _ _ get 和 _ _ set 提供对每个变量的访问，就好像它们是公共的一样..。

在为一个 VB 项目编写代码时，我被要求为每个方法添加以下注释部分

'Module Name
'Module Description
'Parameters and description of each parameter
'Called by
'Calls

虽然我发现其余的都很好，但我反对最后两个，我争论的原因是，随着项目变得越来越大，它将变得难以维护。如果我们正在创建库函数，那么我们永远不能维护。我们是一个6人的小团队，所以经理提出的论点是，既然你要调用函数，就应该维护这个函数。不管怎样，我不得不放弃这个争论，因为经理很固执。结果和预期的一样，随着项目变得越来越大，没有人关心维护 Calleby 和 Call。

当我开始在一个地方工作，并开始将我的代码输入到源代码控制中时，我的老板突然来找我，并要求我停止这么多的承诺。他告诉我，对于开发人员来说，不鼓励每天提交多于1个的任务，因为这会浪费源代码控制。我只是目瞪口呆地看着他..。

后来我才明白，他之所以找到我，是因为 SVN 服务器会给他(以及另外10个高管)发送一封邮件，询问某人的每一次提交。通过乱扔信源控制器，我猜测他是在邮箱里发现的。

首字母缩写大写

DO 除了驼峰大小写标识符的第一个单词之外，两个字符的首字母缩写都要大写。

System.IO
public void StartIO(Stream ioStream)

DO 除了驼峰大小写标识符的第一个单词之外，只将含有三个或更多字符的首字母缩略词的第一个字符大写。

System.Xml
public void ProcessHtmlTag(string htmlTag)

不要在驼峰大小写标识符的开头将任何首字母缩略词的任何字符大写，不管它们的长度如何。

其中一条规则是: < strong > 对已签名数据不进行位操作。 为了找出规则的用途，文中给出了解释: 不能保证已签名数据的位表示。世界上只有2的补充，但是标准没有保证！

不管怎样，这听起来不是什么大事——谁想把比特编码变量声明为带符号的？

然而，神圣的规则检查器将“整数升级”解释为“升级到已签名”，而 C 标准专家则表示必须如此。每个位操作都做整数提升。 所以不是:

a &= ~(1 << i)

你必须写:

a = (unsigned int)(a & (unsigned int)~(unsigned int)(1 << i))

显然更易于阅读和携带。 幸运的是，我发现移位后的1u 没有被签名，所以你可以把它缩减为:

a = (unsigned int)(a & (unsigned int)~(1u << i))

有趣的是，有一条规则没有被激活: 禁止使用“ in # include”这样有趣的字符。DOS 损坏的人们不会相信编写 # include“ bla/foo.h”甚至可以在所有 Windows 编译器上工作，而且更加便携。

The first programming job I had was with a Microsoft QuickBASIC 4.5 shop. The lead developer had been working in BASIC just about forever, so most of the advanced (!) features of QuickBASIC were off-limits because they were new and he didn't understand them. So:

• 没有子程序/结束子程序。一切都用 GOSUB 完成
• 我们被允许不编号线路，不是 GOTO 或 GOSUB 的目标。但 GOTO 的目标必须是一个数字标签，而不是一个名称。
• GOSUB 的目标被允许被命名，但是名字必须以“ S”和一个四位数字作为前缀。所有的子程序都必须在源文件中按顺序排列四位数字。因此，一个典型的例程可能是 S1135InitializePrinter。你必须找到正确的程序来得到号码，有足够的，你不能希望记住他们所有。
• 所有的 IF 都必须有一个 GOTO 或 GOSUB 作为 If判断语句。

- 那真是个有趣的工作-不，说真的。

在 Java 中，我目前不鼓励在测试中使用布尔函数作为谓词:

if( list.isEmpty() )...

必须重写

if( list.isEmpty() == true )...

还有

if( !list.isEmpty() )...

必须重写

if( list.isEmpty() == false )...

因为“这样就更清楚了”。

对我来说，“ list.isEmpty () = = true”有两个动词，“ is”和“ equals”，在一个短语中没有连接词。我不能让它感觉正确。

3个月前，我欣然辞去了上一份工作:

资料库:

• 表名必须是大写的。
• 表名必须前缀为 TBL _
• 字段必须有前缀: DS _ (for 没有任何意义的) NU _ for 数字 CD _ for (“位字段”) DT _ 约会
• Database 字段也必须是大写的[ CD _ ENABLED ]
• 与 SP 名称[ SP _ INFINITY _ USER _ GROUPS _ QRY ]和数据库名称[ INFINITY ]相同
• 我有没有说过 SP 的名字其实是这样的？SP _ prefix，然后数据库名称 SP _ INFINITY _ then table name，SP _ INFINITY _ USER _ GROUPS，然后 SP 实际上应该做什么(QRY，UPD，DEL，INS)上帝，不要让我开始查询不仅仅是 CRUD 查询。
• 所有的文本字段必须是 varchar (MAX) ，毫不含糊。
• 即使您可以使用其他类型，数字也可以是 int 或 double。
• “ boolean”字段(bit)为 int，没有原因。
• 存储过程必须以 sp _ productname _ 为前缀

Net/c #/javascript

• 每个函数都必须包装在 try {} catch {}中，这样应用程序就不会“爆炸”(至少这是官方的原因) ，即使这样会导致程序无法工作，而且不知道为什么。
• 参数必须以 p 作为前缀，例如 pCount，pPage
• 作用域变量必须以 w 作为前缀(就像“工作”一样，这到底是什么意思?)
• 与 g 等的静力学。
• 框架1.1之后的所有东西都是禁止的，就像你对 linq 和泛型有任何实际用途一样。(不过，我特意强制他们允许我使用 jquery，至少我成功了)。

我见过的最糟糕的编码标准就是疯狂的缩进。

这些代码最初是用60x80字符的绿屏终端在大型机上编写的(这是很久以前的事了)。这些东西的默认选项卡大小是8个字符，但当时的程序员认为这太大了——屏幕本身只显示80个字符，所以8个字符的选项卡浪费了很多空间。

因此，他们决定将代码的意图大小设置为4个字符。

你说一切都很公平。除了他们没有改变标签的大小。他们通过将第一个缩进设置为4个空格，将第二个缩进设置为单个制表符，依此类推，在添加4个空格和制表符之间交替进行。

当他们坚持使用绿色屏幕终端的时候，一切都很好，很奇怪，但是很好。

真正的混乱开始时，开发团队得到了他们闪亮的新 Windows 电脑。

他们选择的 PC 编辑器将选项卡大小设置为4个字符，因此当加载代码时，缩进简直是到处都是。

我们无法修复缩进，因为一些开发人员仍在使用绿色屏幕，所以在一年左右的时间里，整个团队都转移到了个人电脑，我们有一个绝对的噩梦，试图处理代码实际上是不可读的，无论是在一个环境或其他(或更频繁地，两者)。