我被分配了读取.txt文件的任务,该文件是各种事件的日志,并将一些事件写入字典.

问题是该文件有时可能大于3GB.这意味着字典太大而无法放入主内存中.Shelve似乎是解决这个问题的好方法.但是,由于我将不断修改字典,我必须writeback启用该选项.这是我担心的地方 - 教程说这会减慢读/写过程并使用更多内存,但我无法找到有关速度和内存如何受影响的统计信息.

任何人都可以澄清读/写速度和内存受到多大影响,以便我可以决定是使用回写选项还是牺牲一些可读性来提高代码效率？

谢谢

考虑这个功能:

int get_result(int *result) {
     int err = 0;
     int number = 0;         

     if (result == NULL) {
         printf("error: null input\n");
         return -1;
     }

     err = get_number(&number);

     if (err != 0) {
         printf("error calling get_number: err = %d\n", err);
         return err;
     }

     err = calculate_result(number, result);

     if (err != 0) {
        printf("error calling get_result: err = %d\n", err);
        return err;
     }

     return err;
}

这个函数的实际工作只需要3行(声明数字变量,调用get_number(),然后调用calculate_result()).但是,错误检查/处理代码会将此功能扩展为17行(给定或接受,具体取决于您对行的计算方式).

在更大规模,多次调用和多次错误检查时,我们完全膨胀该函数并使其难以理解且难以理解.

有什么方法可以解决C代码膨胀问题并保持函数核心操作的可读性(不牺牲基本的错误处理代码)？

我正试图在这里清理这个非常丑陋的方法,那是为了重构而哭泣,但我不确定哪种结构能做到最好(即一个案例陈述,或者只是一个精心设计的if then陈述)

乍一看,它似乎是一个案例陈述的理想场所,有一些很好的位置when,但我的理解是案例陈述只能用于单个变量,而不是两个,以及各种带有irb的小提琴使用散列或数组来尝试这些语句在这里也没有太多亮点.

你会怎么做？在检查这样的多个布尔值时,Ruby中是否有任何常见的技巧来避免这样的代码？

  def has_just_one_kind_of_thing?(item, controller)
    if (controller == 'foos' && item.widgets.blank?) || (controller == 'foos' && item.doohickeys.blank?) || (controller == 'bars' && item.widgets.blank?) || (controller == 'bars' && item.doohickeys.blank?) || (controller == 'bazes' && item.widgets.blank?) || (controller == 'bazes' && item.contraptions.blank?)
      return true
    else 
      return false
    end
  end

我开始.h以最好的意图组织我的文件但不知何故他们变得令人作呕的凌乱.

下面是一个例子(这不是那么糟糕,但我看到更糟糕!).我尝试过分组,#pragma mark但看起来看起来更加混乱.

所有UILabel和UIButtons都是必需的(如上所述),因为它们显示来自Web服务请求的数据,因此如果我们使用Interface Builder来设计GUI,则它们都是必需的.例如,标签可能是产品的"重量"或"高度"特征.

有没有人对如何以最易维护/可读的方式组织这些有任何好的建议？

干杯

我刚开始使用Resharper.它的一个特点是,它建议基于我认为良好的编码实践来改变代码.

它建议的一个变化是在赋值期间将变量类型更改为var.我一直在改变,现在代码到处都是var.不知何故,我感觉"var"关键字使代码有点难以理解.

在可能的情况下使用"var"是否是一个很好的编码实践,或者更好地坚持实际类型.(除了需要使用"var"的匿名类型)

谢谢.

我正在研究Go中的一个程序,它会大量使用MySQL.为了便于阅读,是否可以在INSERT语句中的每个列名后包含列的值？喜欢:

INSERT INTO `table` (`column1` = 'value1', `column2` = 'value2'...);

代替

INSERT INTO `table` (`column`, `column2`,...) VALUES('value1', 'value2'...);

因此,考虑到SQL字符串通常可以获得相当长的时间,因此更容易看出哪个值与哪个列相关联

返回还是不返回，是函数的问题！或者，这真的很重要吗？

故事是这样的：我曾经写过如下代码：

Type3 myFunc(Type1 input1, Type2 input2){}

但是最近我的项目学院告诉我，我应该尽量避免编写这样的函数，并建议通过将返回值放在输入参数中的方式进行以下操作。

void myFunc(Type1 input1, Type2 input2, Type3 &output){}

他们让我相信这是更好更快的，因为在第一种方法中返回时有额外的复制步骤。

对我来说，我开始相信在某些情况下第二种方法更好，尤其是我有很多东西要返回或修改。例如：后面的第二行会比第一行更好更快，因为避免vecor<int>在返回时复制整个。

vector<int> addTwoVectors(vector<int> a, vector<int> b){}
void addTwoVectors(vector<int> a, vector<int> b, vector<int> &result){}:

但是，在其他一些情况下，我无法购买。例如，

bool checkInArray(int value, vector<int> arr){}

肯定会比

void checkInArray(int value, vector<int> arr, bool &inOrNot){}

在这种情况下，我认为直接返回结果的第一种方法在更好的可读性方面更好。

总之，我对（强调 C++）感到困惑：

• 函数应该返回什么，什么不应该（或尽量避免）？
• 有什么标准的方法或好的建议供我遵循吗？
• 我们能否在可读性和代码效率方面做得更好？

编辑：我知道，在某些情况下，我们必须使用其中之一。例如，return-type functions如果我需要实现method chaining. 因此，请关注两种方法都可以实现目标的情况。

我知道这个问题可能没有单一的答案或确定的事情。此外，它似乎这个决定需要在许多编码语言来进行，比如C，C++等于是任何意见或建议，非常感谢（更好的例子）。

我收到了以下代码段的代码审核评论 -

public void doWork(String a, Integer b) {
    ..
    ..
    SomeService service = getService();
    for (Integer i : numbers) {
      doMoreWork(a, b, service);
    }
}
private void doMoreWork(String a, Integer b, SomeService service) {
    ...
    ...
    ...
    service.doingMoreWork(a, b);
}

审查建议 -

1. SomeService service = getService();应该在内部进行调用doMoreWork以便签名清晰.所以签名变得doMoreWork(a, b)更清楚易懂.

我的问题 -

由于doMoreWork()发生在循环中,我将服务对象传递给它.doMoreWork()只是代码中的私有逻辑单元,将"service"作为方法参数进行处理应该没问题.这种方法永远不会公开.这种情况下的指导原则是什么？这里的清晰度或可读性如何受到影响？

(注意 :

1. getService()调用没有太多性能开销,因此性能不是我的标准.
2. 服务注入不是一种选择.它需要以样本中显示的方式获取.
3. doMoreWork()不只是调用service.doingMoreWork().它有一些预先步骤可以遵循.

)

这个问题似乎非常抽象.我会以一个例子来代替.

介绍

假设我有许多类型的游戏对象.

它们是子弹,火箭,敌人,区域......

它们都可以很好地创建,删除和管理,例如

Pool<Bullet> poolBullet ; 
Pool<Rocket> poolRocket ;  

游戏逻辑将以Pool_Handle <xxx>的形式管理对象,例如

Pool_Handle< Bullet >  bullet = poolBullet.create() ;
Pool_Handle< Rocket>  rocket = poolRocket .create() ;

问题

现在,我看看重构.

例如,如果我的旧代码是......

Bullet* functionA(Rocket* rocket){
    for(int n=0;n<rocket->zones.size();n++){
        Zone* zone = rocket->zones.get(n);
        Bullet* return_value =zone.functionB();
    }
}

......它会变成......

Pool_Handle<Bullet> functionA(Pool_Handle<Rocket> rocket){
    for(int n=0;n<rocket->zones.size();n++){
        Pool_Handle<Zone> zone = rocket->zones.get(n);
        Pool_Handle<Bullet> return_value =zone.functionB();
    }
}

请注意,它们现在到处都是Pool_Handle.

在阅读和编辑了几千行代码之后,我已经习惯了 Pool_Handle甚至比任何游戏对象都要多.这可能是我现在输入最快的一个词.

题

如何保持旧代码等级的可读性和可维护性,如果可能的话,如何减少变量模板的键入时间？

我不希望得到一个完美的答案,因为我找到的每个解决方案都有一些权衡.

我糟糕的解决方案

/**  remedy 1 **/
template <class TT> using H …

C# 7 引入了局部嵌套函数。它们为代码提供了更好的结构，但它们是否提高了可读性？是否有任何标准、建议和最佳实践？对于您的眼睛和美感，什么更容易阅读？

class Nested
{
    void Foo()
    {
        void Bar()
        {
        }

        void Baz()
        {
        }

        Bar();
        Baz();
    }
}

class Usual
{
    void Bar()
    {
    }

    void Baz()
    {
    }

    void Foo()
    {
        Bar();
        Baz();
    }
}