开源项目Humanizer介绍

　　humanizer 能够满足您所有.net关于操作和展示以下类型的需求，包括字符串、枚举、日期、时间、时间跨度、数字和数量。它采用 mit 进行授权分发。

 

1、人性化字符串

人性化的字符串扩展名使您可以将原本由计算机处理的字符串转换为更具可读性的人性化字符串。 它的基础是在bddfy框架中设置的，在该框架中，类名，方法名和属性被转换为易于阅读的句子。

"pascalcaseinputstringisturnedintosentence".humanize() => "pascal case input string is turned into sentence"

"underscored_input_string_is_turned_into_sentence".humanize() => "underscored input string is turned into sentence"

"underscored_input_string_is_turned_into_sentence".humanize() => "underscored input string is turned into sentence"

请注意，仅包含大写字母且仅包含一个单词的字符串始终被视为首字母缩写词（无论其长度如何）。 为了确保任何字符串都将始终被人性化，您必须使用转换（请参见下面的transform方法）：

// acronyms are left intact
"html".humanize() => "html"

// any unbroken upper case string is treated as an acronym
"humanizer".humanize() => "humanizer"
"humanizer".transform(to.lowercase, to.titlecase) => "humanizer"

您还可以指定所需的字母大小写：

"canreturntitlecase".humanize(lettercasing.title) => "can return title case"

"can_return_title_case".humanize(lettercasing.title) => "can return title case"

"canreturnlowercase".humanize(lettercasing.lowercase) => "can return lower case"

"canhumanizeintouppercase".humanize(lettercasing.allcaps) => "can humanize into upper case"

lettercasing api和接受它的方法是v0.2时代的遗留物，将来会不推荐使用。 代替的是，您可以使用下面介绍的transform方法。

 

2、非人性化的字符串

就像您可以将计算机友好的字符串人性化为人类友好的字符串一样，您也可以将人类友好的字符串人性化为计算机友好的字符串：

"pascal case input string is turned into sentence".dehumanize() => "pascalcaseinputstringisturnedintosentence"

 

3、转换字符串

有一种transform方法可以代替接受lettercasing的lettercasing，applycase和humanize重载。 转换方法签名如下：

string transform(this string input, params istringtransformer[] transformers)

对于字母大小写，还有一些istringtransformer的现成实现：

"sentence casing".transform(to.lowercase) => "sentence casing"
"sentence casing".transform(to.sentencecase) => "sentence casing"
"sentence casing".transform(to.titlecase) => "sentence casing"
"sentence casing".transform(to.uppercase) => "sentence casing"

lowercase是to类的公共静态属性，它返回私有tolowercase类的实例，该实例实现istringtransformer并知道如何将字符串转换为小写。

与applycase和lettercasing相比，使用transform和istringtransformer的好处是lettercasing是枚举，并且您只能使用框架中的内容，而istringtransformer是可以在代码库中一次实现并与transform方法一起使用的接口，从而可以轻松扩展 。

 

4、截断字符串

您可以使用truncate方法截断字符串：

"long text to truncate".truncate(10) => "long text…"

默认情况下，“ ...”字符用于截断字符串。 使用'...'字符而不是“ ...”的优点是前者仅使用一个字符，因此允许在截断之前显示更多文本。 如果需要，还可以提供自己的截断字符串：

"long text to truncate".truncate(10, "---") => "long te---"

默认的截断策略truncator.fixedlength是将输入字符串截断为特定长度，包括截断字符串的长度。 还有两种其他的截断器策略：一种用于固定数量的（字母数字）字符，另一种用于固定数量的单词。 要在截断时使用特定的截断器，前面示例中显示的两个truncate方法都具有重载，允许您指定用于截断的itruncator实例。 以下是有关如何使用提供的三个截断符的示例：

"long text to truncate".truncate(10, truncator.fixedlength) => "long text…"
"long text to truncate".truncate(10, "---", truncator.fixedlength) => "long te---"

"long text to truncate".truncate(6, truncator.fixednumberofcharacters) => "long t…"
"long text to truncate".truncate(6, "---", truncator.fixednumberofcharacters) => "lon---"

"long text to truncate".truncate(2, truncator.fixednumberofwords) => "long text…"
"long text to truncate".truncate(2, "---", truncator.fixednumberofwords) => "long text---"

请注意，您还可以通过实现itruncator接口来使用创建自己的截断器。

还有一个选项可以选择是从开头（truncatefrom.left）还是结尾（truncatefrom.right）截断字符串。 如上面的示例所示，默认设置为右侧。 下面的示例显示如何从字符串的开头截断：

"long text to truncate".truncate(10, truncator.fixedlength, truncatefrom.left) => "… truncate"
"long text to truncate".truncate(10, "---", truncator.fixedlength, truncatefrom.left) => "---runcate"

"long text to truncate".truncate(10, truncator.fixednumberofcharacters, truncatefrom.left) => "…o truncate"
"long text to truncate".truncate(16, "---", truncator.fixednumberofcharacters, truncatefrom.left) => "---ext to truncate"

"long text to truncate".truncate(2, truncator.fixednumberofwords, truncatefrom.left) => "…to truncate"
"long text to truncate".truncate(2, "---", truncator.fixednumberofwords, truncatefrom.left) => "---to truncate"

 

5、格式化字符串

您可以使用formatwith（）方法设置字符串格式：

"to be formatted -> {0}/{1}.".formatwith(1, "a") => "to be formatted -> 1/a."

这是基于string.format的扩展方法，因此确切的规则适用于它。 如果format为null，则将引发argumentnullexception。 如果传递的参数数目较少，则会引发string.formatexception异常。

您还可以指定区域性以显式用作formatwith（）方法的第一个参数：

"{0:n2}".formatwith(new cultureinfo("ru-ru"), 6666.66) => "6 666,66"

如果未指定区域性，则使用当前线程的当前区域性。

 

6、人性化枚举

直接在枚举成员上调用tostring通常会给用户带来不理想的输出。 解决方案通常是使用descriptionattribute数据注释，然后在运行时读取该注释以获得更友好的输出。 那是一个很好的解决方案。 但是通常，我们只需要在枚举成员的单词之间放置一些空格-这就是string.humanize（）的优点。 对于像这样的枚举：

public enum enumundertest
{
    [description("custom description")]
    memberwithdescriptionattribute,
    memberwithoutdescriptionattribute,
    allcapitals
}

你会得到：

// descriptionattribute is honored
enumundertest.memberwithdescriptionattribute.humanize() => "custom description"

// in the absence of description attribute string.humanizer kicks in
enumundertest.memberwithoutdescriptionattribute.humanize() => "member without description attribute"

// of course you can still apply letter casing
enumundertest.memberwithoutdescriptionattribute.humanize().transform(to.titlecase) => "member without description attribute"

您不仅限于descriptionattribute作为自定义描述。 应用于具有字符串description属性的枚举成员的任何属性都将计数。 这是为了帮助缺少descriptionattribute的平台，也允许使用descriptionattribute的子类。

您甚至可以配置attibute属性的名称以用作描述。

configurator.enumdescriptionpropertylocator = p => p.name == "info"

如果需要提供本地化的描述，则可以改用displayattribute数据注释。

public enum enumundertest
{
    [display(description = "enumundertest_member", resourcetype = typeof(project.resources))]
    member
}

你会得到：

enumundertest.member.humanize() => "content" // from project.resources found under "enumundertest_member" resource key

希望这将有助于避免乱定义带有不必要属性的枚举！

 

7、使枚举非人性化

将字符串人性化，使其原本是人性化的枚举！ 该api如下所示：

public static ttargetenum dehumanizeto<ttargetenum>(this string input)

用法是：

"member without description attribute".dehumanizeto<enumundertest>() => enumundertest.memberwithoutdescriptionattribute

就像humanize api一样，它使用description属性。 您无需提供在人性化过程中提供的外壳：它可以弄清楚。

当在编译时不知道原始enum时，还有一个非泛型对应项：

public static enum dehumanizeto(this string input, type targetenum, nomatch onnomatch = nomatch.throwsexception)

可以像这样使用：

"member without description attribute".dehumanizeto(typeof(enumundertest)) => enumundertest.memberwithoutdescriptionattribute

默认情况下，两个方法都无法将提供的输入与目标枚举进行匹配时抛出nomatchfoundexception。 在非泛型方法中，您还可以通过将第二个可选参数设置为nomatch.returnsnull来要求该方法返回null。

 

8、人性化datetime

您可以对datetime或datetimeoffset的实例进行人性化，并返回一个字符串，该字符串告诉您时间上的倒退或前进时间：

datetime.utcnow.addhours(-30).humanize() => "yesterday"
datetime.utcnow.addhours(-2).humanize() => "2 hours ago"

datetime.utcnow.addhours(30).humanize() => "tomorrow"
datetime.utcnow.addhours(2).humanize() => "2 hours from now"

datetimeoffset.utcnow.addhours(1).humanize() => "an hour from now"

humanizer支持本地和utc日期以及具有偏移量的日期（datetimeoffset）。 您还可以提供要与输入日期进行比较的日期。 如果为null，它将使用当前日期作为比较基础。 另外，可以明确指定要使用的文化。 如果不是，则使用当前线程的当前ui文化。 这是api签名：

public static string humanize(this datetime input, bool utcdate = true, datetime? datetocompareagainst = null, cultureinfo culture = null)
public static string humanize(this datetimeoffset input, datetimeoffset? datetocompareagainst = null, cultureinfo culture = null)

此方法有许多本地化版本。 以下是一些示例：

// in ar culture
datetime.utcnow.adddays(-1).humanize() => "أمس"
datetime.utcnow.adddays(-2).humanize() => "منذ يومين"
datetime.utcnow.adddays(-3).humanize() => "منذ 3 أيام"
datetime.utcnow.adddays(-11).humanize() => "منذ 11 يوم"

// in ru-ru culture
datetime.utcnow.addminutes(-1).humanize() => "минуту назад"
datetime.utcnow.addminutes(-2).humanize() => "2 минуты назад"
datetime.utcnow.addminutes(-10).humanize() => "10 минут назад"
datetime.utcnow.addminutes(-21).humanize() => "21 минуту назад"
datetime.utcnow.addminutes(-22).humanize() => "22 минуты назад"
datetime.utcnow.addminutes(-40).humanize() => "40 минут назад"

datetime.humanize有两种策略：如上所述的默认策略和基于精度的策略。 要使用基于精度的策略，您需要对其进行配置：

configurator.datetimehumanizestrategy = new precisiondatetimehumanizestrategy(precision: .75);
configurator.datetimeoffsethumanizestrategy = new precisiondatetimeoffsethumanizestrategy(precision: .75); // configure when humanizing datetimeoffset

默认精度设置为.75，但是您也可以传递所需的精度。 将精度设置为0.75：

44 seconds => 44 seconds ago/from now
45 seconds => one minute ago/from now
104 seconds => one minute ago/from now
105 seconds => two minutes ago/from now

25 days => a month ago/from now

日期没有非人性化，因为人性化是有损的转换，并且人类友好的日期是不可逆的。

 

9、人性化的时间跨度

您可以在timespan上调用humanize以获得人性化的表示形式：

timespan.frommilliseconds(1).humanize() => "1 millisecond"
timespan.frommilliseconds(2).humanize() => "2 milliseconds"
timespan.fromdays(1).humanize() => "1 day"
timespan.fromdays(16).humanize() => "2 weeks"

timespan.humanize有一个可选的precision参数，它允许您指定返回值的精度。 精度的默认值为1，这意味着仅返回最大的时间单位，如您在timespan.fromdays（16）.humanize（）中看到的那样。 以下是一些指定精度的示例：

timespan.fromdays(1).humanize(precision:2) => "1 day" // no difference when there is only one unit in the provided timespan
timespan.fromdays(16).humanize(2) => "2 weeks, 2 days"

// the same timespan value with different precision returns different results
timespan.frommilliseconds(1299630020).humanize() => "2 weeks"
timespan.frommilliseconds(1299630020).humanize(3) => "2 weeks, 1 day, 1 hour"
timespan.frommilliseconds(1299630020).humanize(4) => "2 weeks, 1 day, 1 hour, 30 seconds"
timespan.frommilliseconds(1299630020).humanize(5) => "2 weeks, 1 day, 1 hour, 30 seconds, 20 milliseconds"

默认情况下，使用精度参数时，空时间单位不计入返回值的精度。 如果您不需要这种行为，则可以将重载的timespan.humanize方法与countemptyunits参数一起使用。 前导的空时间单位永远不会计数。 这是显示空单位计数的区别的示例：

timespan.frommilliseconds(3603001).humanize(3) => "1 hour, 3 seconds, 1 millisecond"
timespan.frommilliseconds(3603001).humanize(3, countemptyunits:true) => "1 hour, 3 seconds"

此方法有许多本地化版本：

// in de-de culture
timespan.fromdays(1).humanize() => "ein tag"
timespan.fromdays(2).humanize() => "2 tage"

// in sk-sk culture
timespan.frommilliseconds(1).humanize() => "1 milisekunda"
timespan.frommilliseconds(2).humanize() => "2 milisekundy"
timespan.frommilliseconds(5).humanize() => "5 milisekúnd"

可以明确指定要使用的文化。 如果不是，则使用当前线程的当前ui文化。 例：

timespan.fromdays(1).humanize(culture: "ru-ru") => "один день"

另外，可以指定最短的时间单位，以避免滚动到较小的单位。 例如：

timespan.frommilliseconds(122500).humanize(minunit: timeunit.second) => "2 minutes, 2 seconds"    // instead of 2 minutes, 2 seconds, 500 milliseconds
timespan.fromhours(25).humanize(minunit: timeunit.day) => "1 day"   //instead of 1 day, 1 hour

另外，可以指定最大时间单位以避免累加到下一个最大单位。 例如：

timespan.fromdays(7).humanize(maxunit: timeunit.day) => "7 days"    // instead of 1 week
timespan.frommilliseconds(2000).humanize(maxunit: timeunit.millisecond) => "2000 milliseconds"    // instead of 2 seconds

默认的maxunit为timeunit.week，因为它可以提供准确的结果。 您可以将此值增加到timeunit.month或timeunit.year，这将为您提供基于每年365.2425天和每月30.436875天的近似值。 因此，月份的间隔为30到31天，每四年为366天。

timespan.fromdays(486).humanize(maxunit: timeunit.year, precision: 7) => "1 year, 3 months, 29 days" // one day further is 1 year, 4 month
timespan.fromdays(517).humanize(maxunit: timeunit.year, precision: 7) => "1 year, 4 months, 30 days" // this month has 30 days and one day further is 1 year, 5 months

如果有多个时间单位，则使用“，”字符串将它们组合起来：

timespan.frommilliseconds(1299630020).humanize(3) => "2 weeks, 1 day, 1 hour"

当timespan为零时，默认行为将返回“ 0”加上最小时间单位。 但是，如果在调用humanize时将true分配给towords，则该方法将返回“ no time”。 例如：

timespan.zero.humanize(1) => "0 milliseconds"
timespan.zero.humanize(1, towords: true) => "no time"
timespan.zero.humanize(1, minunit: humanizer.localisation.timeunit.second) => "0 seconds"

使用collectionseparator参数，可以指定自己的分隔符字符串：

timespan.frommilliseconds(1299630020).humanize(3, collectionseparator: " - ") => "2 weeks - 1 day - 1 hour"

也可以使用当前区域性的集合格式化程序来组合时间单位。 为此，将null指定为collectionseparator参数：

// in en-us culture
timespan.frommilliseconds(1299630020).humanize(3, collectionseparator: null) => "2 weeks, 1 day, and 1 hour"

// in de-de culture
timespan.frommilliseconds(1299630020).humanize(3, collectionseparator: null) => "2 wochen, ein tag und eine stunde"

如果单词优先于数字，则可以设置towords：true参数，以将人性化的timespan中的数字转换为单词：

timespan.frommilliseconds（1299630020）.humanize（3，towords：true）=>“两个星期，一天，一个小时”

 

10、人性化集合

您可以在任何ienumerable上调用humanize，以获取格式正确的字符串，该字符串表示集合中的对象。 默认情况下，将在每个项目上调用tostring（）以获取其表示形式，但是可以将格式化函数传递给humanize。 此外，提供了一个默认的分隔符（英语中为“ and”），但是可以将其他分隔符传递给humanize。

例如：

class someclass
{
    public string somestring;
    public int someint;
    public override string tostring()
    {
        return "specific string";
    }
}

string formatsomeclass(someclass sc)
{
    return string.format("someobject #{0} - {1}", sc.someint, sc.somestring);
}

var collection = new list<someclass>
{
    new someclass { someint = 1, somestring = "one" },
    new someclass { someint = 2, somestring = "two" },
    new someclass { someint = 3, somestring = "three" }
};

collection.humanize()                                    // "specific string, specific string, and specific string"
collection.humanize("or")                                // "specific string, specific string, or specific string"
collection.humanize(formatsomeclass)                     // "someobject #1 - one, someobject #2 - two, and someobject #3 - three"
collection.humanize(sc => sc.someint.ordinalize(), "or") // "1st, 2nd, or 3rd"

修剪项目，并跳过空白（nullorwhitespace）项目。 这导致干净的逗号标点。 （如果有自定义格式器功能，则此功能仅适用于格式器的输出。）

您可以通过实现icollectionformatter并向configurator.collectionformatters注册它来提供自己的集合格式化程序。

 

11、inflector 方法

还有一些 inflector 方法：

 

复数

在考虑不规则和不可数词的情况下，将提供的输入复数化：

"man".pluralize() => "men"
"string".pluralize() => "strings"

通常，您将对单个单词调用pluralize，但如果不确定单词的奇异性，则可以使用可选的inputisknowntobesingular参数调用该方法：

"men".pluralize(inputisknowntobesingular: false) => "men"
"man".pluralize(inputisknowntobesingular: false) => "men"
"string".pluralize(inputisknowntobesingular: false) => "strings"

具有复数参数的pluralize重载已过时，在2.0版中已删除。

 

单数化

单数将提供的输入单数化，同时考虑不规则和不可数的单词：

"men".singularize() => "man"
"strings".singularize() => "string"

通常，您会在一个复数单词上调用单数化，但是如果不确定该单词的复数形式，则可以使用可选的inputisknowntobeplural参数调用该方法：

"men".singularize(inputisknowntobeplural: false) => "man"
"man".singularize(inputisknowntobeplural: false) => "man"
"strings".singularize(inputisknowntobeplural: false) => "string"

具有复数参数的singularize重载已过时，并且在2.0版中已删除。

 

12、添加单词

有时，您可能需要从单数/复数词汇表中添加一条规则（以下示例已在inflector使用的默认词汇表中）：

// adds a word to the vocabulary which cannot easily be pluralized/singularized by regex.
// will match both "salesperson" and "person".
vocabularies.default.addirregular("person", "people");

// to only match "person" and not "salesperson" you would pass false for the 'matchending' parameter.
vocabularies.default.addirregular("person", "people", matchending: false);

// adds an uncountable word to the vocabulary.  will be ignored when plurality is changed:
vocabularies.default.adduncountable("fish");

// adds a rule to the vocabulary that does not follow trivial rules for pluralization:
vocabularies.default.addplural("bus", "buses");

// adds a rule to the vocabulary that does not follow trivial rules for singularization
// (will match both "vertices" -> "vertex" and "indices" -> "index"):
vocabularies.default.addsingular("(vert|ind)ices$", "$1ex");

到数量

很多时候，您想调用单数化和复数化为单词加上数字。 例如 “ 2个请求”，“ 3个男人”。 toquantity为提供的单词加上数字前缀，并相应地对该单词进行复数或单数化：

"case".toquantity(0) => "0 cases"
"case".toquantity(1) => "1 case"
"case".toquantity(5) => "5 cases"
"man".toquantity(0) => "0 men"
"man".toquantity(1) => "1 man"
"man".toquantity(2) => "2 men"

toquantity可以判断输入单词是单数还是复数，并在必要时将单数或复数：

"men".toquantity(2) => "2 men"
"process".toquantity(2) => "2 processes"
"process".toquantity(1) => "1 process"
"processes".toquantity(2) => "2 processes"
"processes".toquantity(1) => "1 process"

您还可以将第二个参数showquantityas传递给toquantity，以指定希望如何输出提供的数量。 默认值为showquantityas.numeric，这是我们在上面看到的。 其他两个值是showquantityas.words和showquantityas.none。

"case".toquantity(5, showquantityas.words) => "five cases"
"case".toquantity(5, showquantityas.none) => "cases"

还有一个重载，允许您格式化数字。 您可以传递要使用的格式和文化。

"dollar".toquantity(2, "c0", new cultureinfo("en-us")) => "$2 dollars"
"dollar".toquantity(2, "c2", new cultureinfo("en-us")) => "$2.00 dollars"
"cases".toquantity(12000, "n0") => "12,000 cases"

序数化

序数化将数字转换为序数字符串，用于表示有序序列（例如1st，2nd，3rd，4th）中的位置：

1.ordinalize() => "1st"
5.ordinalize() => "5th"

您还可以在数字字符串上调用ordinalize并获得相同的结果：“ 21” .ordinalize（）=>“ 21st”

序数化还支持两种形式的语法性别。 您可以将一个参数传递给ordinalize，以指定数字应以哪种性别输出。可能的值为grammaticalgender.masculine，grammmicalgender.feminine和grammaticalgender.neuter：

// for brazilian portuguese locale
1.ordinalize(grammaticalgender.masculine) => "1º"
1.ordinalize(grammaticalgender.feminine) => "1ª"
1.ordinalize(grammaticalgender.neuter) => "1º"
"2".ordinalize(grammaticalgender.masculine) => "2º"
"2".ordinalize(grammaticalgender.feminine) => "2ª"
"2".ordinalize(grammaticalgender.neuter) => "2º"

显然，这仅适用于某些文化。 对于其他通过性别或根本不通过的人，结果没有任何区别。

标题化

titleize将输入的单词转换为title大小写； 等效于“某些标题”。humanize（lettercasing.title）

pascalize

pascalize将输入的单词转换为uppercamelcase，还删除下划线和空格：

"some_title for something".pascalize() => "sometitleforsomething"

camelize

camelize的行为与pascalize相同，但第一个字符为小写：

"some_title for something".camelize() => "sometitleforsomething"

下划线

underscore用下划线分隔输入的单词：

"sometitle".underscore() => "some_title"

dasherize & hyphenate

dasherize和hyphenate用下划线替换下划线：

"some_title".dasherize() => "some-title"
"some_title".hyphenate() => "some-title"

kebaberize

kebaberize用连字符分隔输入的单词，所有单词都转换为小写

"sometext".kebaberize() => "some-text"

 

13、流利的日期

humanizer提供了一种流利的api来处理datetime和timespan，如下所示：

timespan方法：

2.milliseconds() => timespan.frommilliseconds(2)
2.seconds() => timespan.fromseconds(2)
2.minutes() => timespan.fromminutes(2)
2.hours() => timespan.fromhours(2)
2.days() => timespan.fromdays(2)
2.weeks() => timespan.fromdays(14)

每月或一年都没有流利的api，因为一个月可能有28到31天，一年可能是365或366天。

您可以使用这些方法来替换

datetime.now.adddays(2).addhours(3).addminutes(-5)

用

datetime.now + 2.days() + 3.hours() - 5.minutes()

还可以使用三类流利的方法来处理datetime：

in.theyear(2010) // returns the first of january of 2010
in.january // returns 1st of january of the current year
in.februaryof(2009) // returns 1st of february of 2009

in.one.second //  datetime.utcnow.addseconds(1);
in.two.secondsfrom(datetime datetime)
in.three.minutes // with corresponding from method
in.three.hours // with corresponding from method
in.three.days // with corresponding from method
in.three.weeks // with corresponding from method
in.three.months // with corresponding from method
in.three.years // with corresponding from method

on.january.the4th // returns 4th of january of the current year
on.february.the(12) // returns 12th of feb of the current year

和一些扩展方法：

var somedatetime = new datetime(2011, 2, 10, 5, 25, 45, 125);

// returns new datetime(2008, 2, 10, 5, 25, 45, 125) changing the year to 2008
somedatetime.in(2008)

// returns new datetime(2011, 2, 10, 2, 25, 45, 125) changing the hour to 2:25:45.125
somedatetime.at(2)

// returns new datetime(2011, 2, 10, 2, 20, 15, 125) changing the time to 2:20:15.125
somedatetime.at(2, 20, 15)

// returns new datetime(2011, 2, 10, 12, 0, 0) changing the time to 12:00:00.000
somedatetime.atnoon()

// returns new datetime(2011, 2, 10, 0, 0, 0) changing the time to 00:00:00.000
somedatetime.atmidnight()

显然，您也可以将这些方法链接在一起。 例如 2010年11月13日在中午+ 5分钟（）

 

14、数字到数字

humanizer提供了一种流畅的api，该api以更清晰的方式生成（通常是很大的）数字：

1.25.billions() => 1250000000
3.hundreds().thousands() => 300000

 

15、数字到单词

humanizer可以使用towords扩展名将数字更改为单词：

1.towords() => "one"
10.towords() => "ten"
11.towords() => "eleven"
122.towords() => "one hundred and twenty-two"
3501.towords() => "three thousand five hundred and one"

您还可以将第二个参数grammaticalgender传递给towords，以指定应该输出数字的性别。可能的值为grammaticalgender.masculine，grammaticalgender.feminine和grammaticalgender.neuter：

// for russian locale
1.towords(grammaticalgender.masculine) => "один"
1.towords(grammaticalgender.feminine) => "одна"
1.towords(grammaticalgender.neuter) => "одно"

// for arabic locale
1.towords(grammaticalgender.masculine) => "واحد"
1.towords(grammaticalgender.feminine) => "واحدة"
1.towords(grammaticalgender.neuter) => "واحد"
(-1).towords() => "ناقص واحد"

显然，这仅适用于某些文化。 对于传递性别的其他人来说，结果没有任何区别。

另外，可以明确指定要使用的文化。 如果不是，则使用当前线程的当前ui文化。 这是一个例子：

11.towords(new cultureinfo("en")) => "eleven"
1.towords(grammaticalgender.masculine, new cultureinfo("ru")) => "один"

 

16、数字到序数词

这是将towords与ordinalize混合在一起的一种。 您可以在数字上调用toordinalwords以获得数字中单词的序号表示！ 例如：

0.toordinalwords() => "zeroth"
1.toordinalwords() => "first"
2.toordinalwords() => "second"
8.toordinalwords() => "eighth"
10.toordinalwords() => "tenth"
11.toordinalwords() => "eleventh"
12.toordinalwords() => "twelfth"
20.toordinalwords() => "twentieth"
21.toordinalwords() => "twenty first"
121.toordinalwords() => "hundred and twenty first"

toordinalwords也支持语法性别。 您可以将第二个参数传递给toordinalwords以指定输出的性别。 可能的值为grammaticalgender.masculine，grammmicalgender.feminine和grammaticalgender.neuter：

// for brazilian portuguese locale
1.toordinalwords(grammaticalgender.masculine) => "primeiro"
1.toordinalwords(grammaticalgender.feminine) => "primeira"
1.toordinalwords(grammaticalgender.neuter) => "primeiro"
2.toordinalwords(grammaticalgender.masculine) => "segundo"
2.toordinalwords(grammaticalgender.feminine) => "segunda"
2.toordinalwords(grammaticalgender.neuter) => "segundo"

// for arabic locale
1.toordinalwords(grammaticalgender.masculine) => "الأول"
1.toordinalwords(grammaticalgender.feminine) => "الأولى"
1.toordinalwords(grammaticalgender.neuter) => "الأول"
2.toordinalwords(grammaticalgender.masculine) => "الثاني"
2.toordinalwords(grammaticalgender.feminine) => "الثانية"
2.toordinalwords(grammaticalgender.neuter) => "الثاني"

显然，这仅适用于某些文化。 对于传递性别的其他人来说，结果没有任何区别。

另外，可以明确指定要使用的文化。 如果不是，则使用当前线程的当前ui文化。 这是一个例子：

10.toordinalwords(new cultureinfo("en-us")) => "tenth"
1.toordinalwords(grammaticalgender.masculine, new culureinfo("pt-br")) => "primeiro"

 

17、日期时间到序数词

这是ordinalize的扩展

// for english uk locale
new datetime(2015, 1, 1).toordinalwords() => "1st january 2015"
new datetime(2015, 2, 12).toordinalwords() => "12th february 2015"
new datetime(2015, 3, 22).toordinalwords() => "22nd march 2015"
// for english us locale
new datetime(2015, 1, 1).toordinalwords() => "january 1st, 2015"
new datetime(2015, 2, 12).toordinalwords() => "february 12th, 2015"
new datetime(2015, 3, 22).toordinalwords() => "march 22nd, 2015"

toordinalwords也支持语法大小写。 您可以将第二个参数传递给toordinalwords以指定输出的大小写。 可能的值是grammaticalcase.nominative，grammmicalcase.genitive，grammmicalcase.dative，grammmicalcase.accusative，grammmicalcase.instrumental和graammaticalgender。介词：

显然，这仅适用于某些文化。 对于其他人来说，通过案例不会对结果产生任何影响。

 

18、罗马数字

humanizer可以使用toroman扩展名将数字更改为罗马数字。 数字1到10可以用罗马数字表示如下：

1.toroman() => "i"
2.toroman() => "ii"
3.toroman() => "iii"
4.toroman() => "iv"
5.toroman() => "v"
6.toroman() => "vi"
7.toroman() => "vii"
8.toroman() => "viii"
9.toroman() => "ix"
10.toroman() => "x"

也可以使用fromroman扩展名进行反向操作。

"i".fromroman() => 1
"ii".fromroman() => 2
"iii".fromroman() => 3
"iv".fromroman() => 4
"v".fromroman() => 5

请注意，只有小于4000的整数才能转换为罗马数字。

 

19、公制数字

humanizer可以使用tometric扩展名将数字更改为公制数字。 数字1、1230和0.1可以用公制数字表示，如下所示：

1d.tometric() => "1"
1230d.tometric() => "1.23k"
0.1d.tometric() => "100m"

也可以使用frommetric扩展进行相反的操作。

1d.tometric() => "1"
1230d.tometric() => "1.23k"
0.1d.tometric() => "100m"

"1".frommetric() => 1
"1.23k".frommetric() => 1230
"100m".frommetric() => 0.1

 

20、字节大小

humanizer包含出色的bytesize库的端口。 对bytesize进行了许多更改和添加，以使与bytesize的交互更容易且与humanizer api更加一致。 这是一些如何从数字转换为字节大小以及在大小幅值之间转换的示例：

var filesize = (10).kilobytes();

filesize.bits      => 81920
filesize.bytes     => 10240
filesize.kilobytes => 10
filesize.megabytes => 0.009765625
filesize.gigabytes => 9.53674316e-6
filesize.terabytes => 9.31322575e-9

有几种扩展方法可让您将数字转换为bytesize实例：

3.bits();
5.bytes();
(10.5).kilobytes();
(2.5).megabytes();
(10.2).gigabytes();
(4.7).terabytes();

您还可以使用+/-运算符和加/减方法对值进行加/减：

var total = (10).gigabytes() + (512).megabytes() - (2.5).gigabytes();
total.subtract((2500).kilobytes()).add((25).megabytes());

bytesize对象包含两个属性，它们代表最大的度量标准前缀符号和值：

var maxfilesize = (10).kilobytes();

maxfilesize.largestwholenumbersymbol;  // "kb"
maxfilesize.largestwholenumbervalue;   // 10

如果要使用字符串表示形式，则可以在bytesize实例上互换调用tostring或humanize：

7.bits().tostring();           // 7 b
8.bits().tostring();           // 1 b
(.5).kilobytes().humanize();   // 512 b
(1000).kilobytes().tostring(); // 1000 kb
(1024).kilobytes().humanize(); // 1 mb
(.5).gigabytes().humanize();   // 512 mb
(1024).gigabytes().tostring(); // 1 tb

您还可以选择提供期望的字符串表示形式的格式。 格式化程序可以包含要显示的值的符号：b，b，kb，mb，gb，tb。 格式化程序使用内置的double.tostring方法，将＃。##作为默认格式，该格式将数字四舍五入到小数点后两位：

var b = (10.505).kilobytes();

// default number format is #.##
b.tostring("kb");         // 10.52 kb
b.humanize("mb");         // .01 mb
b.humanize("b");          // 86057 b

// default symbol is the largest metric prefix value >= 1
b.tostring("#.#");        // 10.5 kb

// all valid values of double.tostring(string format) are acceptable
b.tostring("0.0000");     // 10.5050 kb
b.humanize("000.00");     // 010.51 kb

// you can include number format and symbols
b.tostring("#.#### mb");  // .0103 mb
b.humanize("0.00 gb");    // 0 gb
b.humanize("#.## b");     // 10757.12 b

如果要使用完整单词的字符串表示形式，可以在bytesize实例上调用tofullwords：

7.bits().tofullwords();           // 7 bits
8.bits().tofullwords();           // 1 byte
(.5).kilobytes().tofullwords();   // 512 bytes
(1000).kilobytes().tofullwords(); // 1000 kilobytes
(1024).kilobytes().tofullwords(); // 1 megabyte
(.5).gigabytes().tofullwords();   // 512 megabytes
(1024).gigabytes().tofullwords(); // 1 terabyte

没有dehumanize方法可以将字符串表示形式转换回bytesize实例。 但是您可以对bytesize使用parse和tryparse来做到这一点。 像其他tryparse方法一样，bytesize.tryparse返回布尔值，该值指示解析是否成功。 如果解析了该值，则将其输出到提供的out参数：

 

bytesize output;
bytesize.tryparse("1.5mb", out output);

// invalid
bytesize.parse("1.5 b");   // can't have partial bits

// valid
bytesize.parse("5b");
bytesize.parse("1.55b");
bytesize.parse("1.55kb");
bytesize.parse("1.55 kb "); // spaces are trimmed
bytesize.parse("1.55 kb");
bytesize.parse("1.55 mb");
bytesize.parse("1.55 mb");
bytesize.parse("1.55 mb");
bytesize.parse("1.55 gb");
bytesize.parse("1.55 gb");
bytesize.parse("1.55 gb");
bytesize.parse("1.55 tb");
bytesize.parse("1.55 tb");
bytesize.parse("1.55 tb");

最后，如果您需要计算传输一定数量字节的速率，则可以使用bytesize的per方法。 per方法接受一个参数-字节的测量间隔； 这是传输字节所花费的时间。

per方法返回具有humanize方法的byterate类。 默认情况下，速率以秒为单位（例如mb / s）。 但是，如果需要，可以在另一个间隔内将timeunit传递给humanize。 有效间隔是timeunit.second，timeunit.minute和timeunit.hour。 下面是每个间隔的示例以及字节率的示例。

var size = bytesize.frommegabytes(10);
var measurementinterval = timespan.fromseconds(1);

var text = size.per(measurementinterval).humanize();
// 10 mb/s

text = size.per(measurementinterval).humanize(timeunit.minute);
// 600 mb/min

text = size.per(measurementinterval).humanize(timeunit.hour);
// 35.15625 gb/hour

您可以为人性化输出的字节部分指定格式：

 

19854651984.bytes().per(1.seconds()).humanize("#.##");
// 18.49 gb/s

 

21、角度到单词

humanizer包括将数字标题更改为单词的方法。 标题可以是双精度，而结果将是字符串。 您可以选择返回标题的完整表示形式（例如，北，东，南或西），简短表示形式（例如，n，e，s，w）还是unicode箭头字符（例如，↑，→，↓，←） ）。

360.toheading();
// north
720.toheading();
// north

为了检索标题的简短版本，您可以使用以下调用：

180.toheading(true);
// s
360.toheading(true);
// n

请注意，文字表示的最大偏差为11.25°。

最重要的是，这些方法都有一个重载，您可以使用它提供一个cultureinfo对象，以确定要返回的本地化结果。

要检索表示标题的箭头，请使用以下方法：

90.toheadingarrow();
// →
225.toheadingarrow();
// ↙

标题的箭头表示最大偏差为22.5°。

为了检索基于短文本表示形式的标题（例如n，e，s，w），可以使用以下方法：

"s".fromshortheading();
// 180
"sw".fromshortheading();
// 225

 

22、元组化

humanizer 可以使用tupleize将整数更改为其“元组”。 例如：

1.tupleize();
// single
3.tupleize();
// triple
100.tupleize();
// centuple

数字1-10、100和1000将转换为“命名”元组（即“单”，“双”等）。 任何其他数字“ n”将转换为“ n元组”。

 

humanizer 混合到您的框架中以简化您的生活

这只是一个基础，您可以使用它来简化您的日常工作。 例如，在asp.net mvc中，我们一直在viewmodel属性上保留display属性，以便htmlhelper可以为我们生成正确的标签。 但是，就像枚举一样，在大多数情况下，我们只需要在属性名称中的单词之间留一个空格-那么为什么不使用“ string” .humanize呢？

您可能会在执行该操作的代码中找到一个asp.net mvc示例（尽管该项目已从解决方案文件中排除，从而使nuget包也可用于.net 3.5）。

这是通过使用名为humanizermetadataprovider的自定义dataannotationsmodelmetadataprovider实现的。 它足够小，可以在这里重复； 所以我们开始：

using system;
using system.collections.generic;
using system.componentmodel;
using system.componentmodel.dataannotations;
using system.linq;
using system.web.mvc;
using humanizer;

namespace yourapp
{
    public class humanizermetadataprovider : dataannotationsmodelmetadataprovider
    {
        protected override modelmetadata createmetadata(
            ienumerable<attribute> attributes,
            type containertype,
            func<object> modelaccessor,
            type modeltype,
            string propertyname)
        {
            var propertyattributes = attributes.tolist();
            var modelmetadata = base.createmetadata(propertyattributes, containertype, modelaccessor, modeltype, propertyname);

            if (istransformrequired(modelmetadata, propertyattributes))
                modelmetadata.displayname = modelmetadata.propertyname.humanize();

            return modelmetadata;
        }

        private static bool istransformrequired(modelmetadata modelmetadata, ilist<attribute> propertyattributes)
        {
            if (string.isnullorempty(modelmetadata.propertyname))
                return false;

            if (propertyattributes.oftype<displaynameattribute>().any())
                return false;

            if (propertyattributes.oftype<displayattribute>().any())
                return false;

            return true;
        }
    }
}

此类调用基类以提取元数据，然后根据需要使属性名称人性化。 它正在检查属性是否已经具有displayname或display属性，在这种情况下，元数据提供程序将仅接受该属性，而保留该属性。 对于其他属性，它将人性化属性名称。 就这些。

现在，您需要使用asp.net mvc注册该元数据提供程序。 确保使用system.web.mvc.modelmetadataproviders，而不使用system.web.modelbinding.modelmetadataproviders：

modelmetadataproviders.current = new humanizermetadataprovider();

...现在您可以替换：

public class registermodel
{
    [display(name = "user name")]
    public string username { get; set; }

    [display(name = "email address")]
    public string emailaddress { get; set; }

    [display(name = "confirm password")]
    public string confirmpassword { get; set; }
}

用

public class registermodel
{
    public string username { get; set; }
    public string emailaddress { get; set; }
    public string confirmpassword { get; set; }
}

 

...，“元数据人性化工具”将负责其余的工作。

无需提及，如果您想为标签加上标题框，则可以使用transform链接方法：

modelmetadata.displayname = modelmetadata.propertyname.humanize().transform(to.titlecase);

 

已知的安装问题和解决方法

由于cli工具中的错误，主要的humanizer软件包及其语言软件包将无法安装。 作为临时解决方法，在修复该错误之前，请改用humanizer.xproj。 它包含所有语言。

 

 

github地址：https://github.com/humanizr/humanizer