我知道我们许多人使用经常使用的工具和实用程序来维护自己的小型个人图书馆。

我从16岁起就拥有我的，所以它的规模已经发展到相当可观的水平。此后，我写的一些内容已添加到框架中。我在LINQ之前就编写了自己的表达树的小实现，用于遗传算法，这在当时我很喜欢，并为此感到自豪-当然，现在它已经毫无用处了。但是最近我一直在研究它并升级到.NET 4.0，并重新引起了人们的兴趣。

所以我很好奇您使用库的目的。也许我们可以得到一些有用的小片段的好主意，并在我们自己之间分享。

所以我的问题是：

• 您是否有其他实用程序库？
• 您最为哪一部分感到自豪，为什么？

如果您愿意，请提供代码示例 :-)

没有。

我已经看到了十几个开发人员的噩梦，他们都在项目中添加了自己的小“ util.h”样式库，并使它变成了功能命名和行为不一致的巨大混乱。很像PHP。因此，出于这个原因，我避免这样做。

我避免使用编程环境来做到这一点，因为编程环境会尽可能为我提供几乎所有我需要的工具和库，例如C＃和python。

智能格式

我最喜欢的实用程序是我编写的实用程序-一种简单的字符串生成器/格式化程序，可以很容易地将数据转换为具有正确语法的字符串。

例如，大多数程序员都从模板构建文本： "There are {0} items remaining" 但这会导致语法错误："There are 1 items remaining"。

因此，SmartFormat可让您编写："There {0:is|are} {0} item{0:|s} remaining"。

您只需替换String.Format(...)为Smart.Format(...)就可以了！

该SmartFormat代码是开源：http://github.com/scottrippey/SmartFormat/wiki

K组合器（C＃，Scala）

我经常在Ruby中使用K组合器，当通过副作用而不是返回值执行折叠操作时，大多数情况下是在折叠中使用，例如以下示例：

some_collection.reduce(Hash.new(0)) {|acc, el| acc[el] += 1 }

这将计算每个元素在中出现的频率some_collection。不幸的是，它实际上并不起作用，因为该块必须在每次迭代时返回累加器的新值，但是在Ruby中，赋值运算为赋值。

因此，您必须像这样精确地返回累加器的新值：

some_collection.reduce(Hash.new(0)) {|acc, el| acc[el] += 1; acc }

但是我发现这种显式的排序很丑陋，使用折叠功能。使用K组合器（Object#tap在Ruby中称为）：

some_collection.reduce(Hash.new(0)) {|acc, el| acc.tap { acc[el] += 1 }}

我已经在C＃中错过了几次（主要是由于某种原因，集合变量（例如List.Addreturn void而不是this）和Scala），所以我解决了这个问题：

namespace GenericExtensions
{
    public static class GenericExtensions
    {
        public static T Tap<T>(this T o, Action<T> f)
        {
            Contract.Requires(o != null);
            Contract.Requires(f != null);

            f(o);
            return o;
        }

        public static T Tap<T>(this T o, Action f)
        {
            Contract.Requires(o != null);
            Contract.Requires(f != null);

            f();
            return o;
        }
    }
}

在Scala中：

class Tap[T](o: T) {
  def tap(f: T => Unit) = { f(o); o }
  def tap(f: => Unit) = { f; o }
}

object Implicits { implicit def any2Tap[T](o: T) = new Tap(o) }

身份功能（Ruby）

我在Ruby中缺少的东西是一种访问身份函数的好方法。Haskell在名称下提供身份功能id，Scala 名称下提供Scala identity。这样一来，您可以编写如下代码：

someCollection.groupBy(identity)

Ruby中的等效项是

some_collection.group_by {|x| x }

不会完全从舌头上滑下来吗？

解决方法是

IDENTITY = -> x { x }

some_collection.group_by(&IDENTITY)

ForEach（.NET）

C＃中另一个非常缺失的方法：

namespace IEnumerableExtensions
{
    public static class IEnumerableExtensions
    {
        public static void ForEach<T>(this IEnumerable<T> xs, Action<T> f)
        {
            Contract.Requires(xs != null);
            Contract.Requires(f != null);

           foreach (var x in xs) f(x);
        }
    }
}

我有一个Java类型转换器。具有公开签名

public static <T> T convert(Object sourceValue, Class<T> destinationType)

并尽最大努力将源值转换为目标类型。本质上，它使您可以在静态类型的语言中进行动态键入：-)

实际上，对于装箱的数字类型很有用。你不能把期望放在Integer哪里Long是多么令人烦恼？没问题，只需将其转换即可。或者，如果您的函数需要一个double，但又要null放一个呢？NPE Kaboom。但是经过它convert，你会得到一个NaN。

在我编写的混杂代码中，大多数好东西现在都在CCAN中，而其余​​的我倾向于在现有的开源项目中找到更好的版本。最近，我发现自己编写的通用“ misc”代码越来越少，倾向于编写此类代码的特定于应用程序的变体，或者编写自己可以释放的通用模块。

C

这是我已使用多次的函数和typedef。对于需要定时的应用程序，在简单性方面很难超过毫秒：

#include <stdint.h>
#include <sys/time.h>

typedef int64_t msec_t;

static msec_t time_ms(void)
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return (msec_t)tv.tv_sec * 1000 + tv.tv_usec / 1000;
}

以及我倾向于一遍又一遍地使用的其他各种C函数：

/* Remove a trailing newline, if present. */
void chomp(char *buffer)
{
    if (!*buffer)
        return;

    while (*buffer)
        buffer++;

    if (buffer[-1] == '\n')
        buffer[-1] = 0;
}

/*
 * Skip whitespace, update the pointer, and return it.
 * Example:
 *
 * switch (*skipSpace(&s)) {
 *     case '\0':
 *         ...
 *     case '(':
 *         ...
 */
const char *skipSpace(const char **sptr)
{
    const char *s = *sptr;
    while (isspace(*s))
        s++;
    *sptr = s;
    return s;
}

/* Scramble an array of items uniformly. */
void scramble(void *base, size_t nmemb, size_t size)
{
    char *i = base;
    char *o;
    size_t sd;
    for (;nmemb>1;nmemb--) {
        o = i + size*(rand()%nmemb);
        for (sd=size;sd--;) {
            char tmp = *o;
            *o++ = *i;
            *i++ = tmp;
        }
    }
}

哈斯克尔

Haskell的nub :: (Eq a) => [a] -> [a]函数为O（n²），因为根据其类型签名，它只能测试两个元素是否相等。一个简单的O（n log n）替代方法是map head . group . sort，但是它需要在产生输出之前强制执行整个输入列表，而nub可以立即开始产生输出。以下是O（n log n）的替代方案，nub该方案收集a中已经看到的项目Data.Set：

module Nub (nub') where

import Prelude
import Data.Set (empty, member, insert)

nub' :: Ord a => [a] -> [a]
nub' xs = loop xs empty where
    loop [] _ = []
    loop (x:xs) set =
        if x `member` set
            then loop xs set
            else x : loop xs (insert x set)

在Haskell中，我使用的替代品sequence，mapM，forM，replicateM，和filterM。这些操作都会生成一个列表，但是只有在操作完整完成后才能使用该列表（如果您使用的是像IO这样的严格monad）。替代方案以相反的方式建立了列表，而不是形成笨拙的塔楼，我通过基准测试发现，至少在GHC模式下，它更快。

sequence' :: Monad m => [m a] -> m [a]
sequence' ms = loop ms [] >>= return . reverse where
    loop []     xs = return xs
    loop (m:ms) xs = do
        x <- m
        loop ms (x:xs)

mapM' :: Monad m => (a -> m b) -> [a] -> m [b]
mapM' f xs = sequence' $ map f xs

forM' :: Monad m => [a] -> (a -> m b) -> m [b]
forM' = flip mapM'

replicateM' :: Monad m => Int -> m a -> m [a]
replicateM' n x = sequence' (replicate n x)

filterM' :: Monad m => (a -> m Bool) -> [a] -> m [a]
filterM' pred xs = loop xs [] >>= return . reverse where
    loop []     xs' = return xs'
    loop (x:xs) xs' = do
        keep <- pred x
        loop xs (if keep then (x:xs') else xs')

注：sequence_，mapM_，forM_，和replicateM_功能仍然是一个更好的选择，如果你没有在结果列表感兴趣。

我最终用没有它的语言实现了split / join ala Perl。

我还用C重新实现了atoi和itoa的次数比我想的要多（嵌入式系统垃圾）。

没有。

我用Java编写大部分代码，最佳实践是重用Apache Commons库和类似项目中的“ utils”。

如果您对此持客观态度，那么在少数情况下，您自己的“实用程序”集合将大大改善其他人已经做的事情。而且，如果这不是一个改进，那么您的utils库可能会浪费开发时间，并且会给以后的维护者带来麻烦/负担。

我使用Java执行了一些日期操作，然后开始使用JodaTime，因为我听说过有关它的好东西，并将其包含在Java 7中（不确定是否仍然存在，但即使不是，也仍然如此）非常值得使用imho）。

它通过大约三个链接的方法调用将50+行类转换为一行。

出于好奇，它涉及获取过去n周的每一天的日期：例如10周前的星期一的销售数字，等等）。

这是其中的一部分

public static DateTime getDayPreviousWeek(DateTime dt, DayOfWeek dayOfWeek, int n_weeks) {
       return dt.minusWeeks(n_weeks).dayOfWeek().setCopy(dayOfWeek.getDayAsString());
}

我总是有某种utils软件包，即使使用Java也是如此，但是我的PHP utils集合使用得最多。Java有很多好的库，因此我要么已经在项目中包含一个库，要么只需要自己设计一些缺少的utils。PHP库对于我来说想做太多了，想将它们包含在我的项目中。

我有点喜欢PHP的此功能，并在StackOverflow的帮助下进行了完善 ...

function getValueFromDotKey(&$context, $name) {
    $pieces = explode('.', $name);
    foreach ($pieces as $piece) {
        if (!is_array($context) || !array_key_exists($piece, $context)) {
            // error occurred
            return null;
        }
        $context = &$context[$piece];
    }
    return $context;
}

它类似于Apache的Java BeanUtils，我将其用于类似目的，为模板语言的表单元素提供了一个单键，该键可以获取/设置源数组中的嵌套值：

$source = array('a' => array('b' => 5));

$val = getValueFromDotKey($source, 'a.b');

当然，作为PHP，我想保持的方法轻量级越好，所以它不是相当的多特征为BeanUtils的;)

Scala标准库缺少一些最常用的高阶函数。

我最需要的两个此类功能：

// #1: unfold
def unfold[T, R](init: T)(f: T => Option[(R, T)]): List[R] = f(init) match {
  case None => Nil
  case Some(r, v) => r :: unfold(v)(f)
}

// #2: zipWith
def zipWith[A, B, C](xs: List[A], ys: List[B])(f: (A, B) => C): List[C] = {
  (xs, ys).zipped.map(f)
}

目前没有。当我使用C语言时，我只有一个，但是现在我使用Java，考虑到所有可用的标准库以及来自Apache项目的所有好处，它不再有意义。

我的C库中有用的东西之一是快速脏的有限状态机实现，该实现允许只用两个字符串和一个字符串数组定义一个有限状态机。它可以用来根据规则检查字符串（例如“必须长4..6个字符，第一个字母是字母，其余数字”），但是正则表达式的可用性使这一点变得毫无意义。

我现在不能在没有基于动态执行的动态对话框的情况下编写桌面用户界面。这是我在1985年左右偶然发现的一种骇客，而且我用各种语言重新实现它的次数比我记得的要多。

我发现我在django中编写了很多相同的代码，先做这个普通的事情，然后做这个普通的事情，最后做那个普通的事情。基本上是从数据库中获取一项或多项，或者保存表单的结果。

如果这些事情中的每一项仅在视图中发生一次，那么我可以使用django通用视图。不幸的是，这些并不是真正可组合的，我需要按顺序做几件事。

因此，我去写了一个更为通用的视图库，该库首先通过从相关查询集（或其他查询集）构建动作列表，然后将列表包装到视图中来工作。

我仍然必须手动编写一些视图，但是这些视图通常足够复杂，以至于其中没有太多可重用的视图。所有样板文件都可以在通用视图或视图装饰器（通常是经过修饰的通用视图）中放到其他地方。由于某些通用处理程序可以完成其他所有操作，因此通常最终只占我编写的处理程序的10％。

是的，但仅适用于特定领域的习惯用语结构（例如特定于游戏对象的容器）。

由于它是简单的实用工具，而不是任何复杂的工具，因此我对此并不感到骄傲。无论如何，我现在是唯一的用户，因此没有什么值得骄傲的。

基于STL sort和仿函数模板的C ++间接排序。

在许多项目中，对间接排序的需求（其中期望的输出是排序数据所产生的排列索引，而不是排序后的数据本身）的需求出现了很多次。我一直想知道为什么STL没有为其提供实现。

另一个是C ++循环向量，其中正负索引与向量大小成模（这样，任何整数值都是向量的有效索引）。

我在Comp进行Java开发时写了一个小的utils程序包。高中科学课。我为我的随机数生成器感到最自豪。

/**
* Returns a random integer.
*
* @returns    int    Random integer
*/
public static int getRandom()
{
    return 4; // Chosen by a fair dice roll.
              // Guaranteed to be random.
}

^{支撑我的灵感。}