Question

我在this answer做了一些游戏，甚至向Apple提出了RADAR问题，要求提供更好的文件记录（蟋蟀唧唧喳喳）。

问题是：字符串间隔如何工作？

如果你看看我操场上的第367行，你会发现我弄乱了字符串间隔。

我将String的内容提取到一个较小的游乐场中：

// String Intervals
// These are odd. Looks like it is using the ASCII values. I should experiment with Unicode, and see where we go...
let aThroughFClosed:ClosedInterval<String>          = "A"..."F"
let dThroughQClosed:ClosedInterval                  = "D"..."Q"
let mThroughSClosed:ClosedInterval                  = "M"..."S"
let tThroughWClosed:ClosedInterval                  = "T"..."W"
let whiskeyTangoFoxtrot1                            = "QED"..."WTF" /* Not sure what will happen when I start working with this... */
let aThroughHHalfOpen:HalfOpenInterval<String>      = "A"..<"H"
let dThroughRHalfOpen:HalfOpenInterval              = "D"..<"R"
let mThroughTHalfOpen:HalfOpenInterval              = "M"..<"T"
let tThroughXHalfOpen:HalfOpenInterval              = "T"..<"X"
let whiskeyTangoFoxtrot2                            = "QED"..<"WTF"
let clampedString1 = aThroughFClosed.clamp ( dThroughQClosed )  /* This represents "D"..."F" */
let clampedString2 = dThroughQClosed.clamp ( aThroughFClosed )  /* This represents "D"..."F" */
let clampedString3 = dThroughQClosed.clamp ( mThroughSClosed )  /* This represents "M"..."Q" */
let clampedString4 = dThroughQClosed.clamp ( tThroughWClosed )  /* This represents "Q"..."Q" */
let clampedString5 = aThroughFClosed.clamp ( tThroughWClosed )  /* This represents "F"..."F" */
let clampedString6 = aThroughHHalfOpen.clamp ( dThroughRHalfOpen )  /* This represents "D"..<"G" */
let clampedString7 = dThroughRHalfOpen.clamp ( aThroughHHalfOpen )  /* This represents "D"..<"H" */
let clampedString8 = dThroughRHalfOpen.clamp ( mThroughTHalfOpen )  /* This represents "M"..<"R" */
let clampedString9 = dThroughRHalfOpen.clamp ( tThroughXHalfOpen )  /* This represents "R"..<"R" */
let clampedString0 = aThroughHHalfOpen.clamp ( tThroughXHalfOpen )  /* This represents "H"..<"H" (Not exactly sure why) */

// 2.2.3: STRING INTERVALS

// String intervals are weird. Just sayin'...

// 2.2.3.1: STRING INTERVALS AS SWITCH TESTS

var testValue3:String = "B"

switch ( testValue3 )
    {
case aThroughFClosed:   /* This will catch it. */
    println ( "In A...F." )

default:
    println ( "In catchall." )
}

// Looks like the test is only on the first letter.
testValue3 = "Badz-Maru"

switch ( testValue3 )
    {
case aThroughFClosed:   /* This will catch it. */
    println ( "In A...F." )

default:
    println ( "In catchall." )
}

testValue3 = "\tBadz-Maru"   /* If we add a tab character to the start of the string, then the first test will fail. */

switch ( testValue3 )
    {
case aThroughFClosed:
    println ( "In A...F." )

default:    /* This will catch it. */
    println ( "In catchall." )
}

// Now, we'll get really strange. Let's look at our multi-character intervals...

testValue3 = "W"

switch ( testValue3 )
    {
case whiskeyTangoFoxtrot2:  /* This catches it. */
    println ( "WTF, dude?" )

default:
    println ( "In catchall." )
}

testValue3 = "T"

switch ( testValue3 )
    {
case whiskeyTangoFoxtrot2:  /* This catches it. */
    println ( "WTF, dude?" )

default:
    println ( "In catchall." )
}

testValue3 = "F"

switch ( testValue3 )
    {
case whiskeyTangoFoxtrot2:
    println ( "WTF, dude?" )

default: /* However, in this case, it falls through to default. */
    println ( "In catchall." )
}

testValue3 = "WT"

switch ( testValue3 )
    {
case whiskeyTangoFoxtrot2: /* "WT" is caught. */
    println ( "WTF, dude?" )

default:
    println ( "In catchall." )
}

testValue3 = "WTF"

switch ( testValue3 )
    {
case whiskeyTangoFoxtrot2:
    println ( "WTF, dude?" )

default:    /* "WTF" is not caught. */
    println ( "In catchall." )
}

testValue3 = "QED"

switch ( testValue3 )
    {
case whiskeyTangoFoxtrot2:  /* "QED" is caught. */
    println ( "WTF, dude?" )

default:
    println ( "In catchall." )
}

testValue3 = "QTF"

switch ( testValue3 )
    {
case whiskeyTangoFoxtrot2:  /* "QTF" is caught. */
    println ( "WTF, dude?" )

default:
    println ( "In catchall." )
}

testValue3 = "QSF"

switch ( testValue3 )
    {
case whiskeyTangoFoxtrot2:  /* "QSF" is caught. */
    println ( "WTF, dude?" )

default:
    println ( "In catchall." )
}

testValue3 = "QAF"

switch ( testValue3 )
    {
case whiskeyTangoFoxtrot2:
    println ( "WTF, dude?" )

default: /* QAF falls through. */
    println ( "In catchall." )
}

Answer 1

据我了解，ClosedInterval(lo, hi)代表所有字符串s，以便

lo <= s <= hi

和HalfOpenInterval(lo, hi)代表所有字符串s，以便

lo <= s < hi

其中<=和<由字符串的 词典排序 决定，即逐个比较字符，直到找到差异。

例如"QED" < "T" < "WTF"，因为Q < T < W，但"F" < "QED"因为 F < Q。因此

HalfOpenInterval("QED" , "WTF").contains("T") == true
HalfOpenInterval("QED" , "WTF").contains("F") == false

"QED" < "QSF"因为Q == Q和E < S，而"QAF" < "QED"因为Q == Q和A < E。因此

HalfOpenInterval("QED" , "WTF").contains("QSF") == true
HalfOpenInterval("QED" , "WTF").contains("QAF") == false

这应该解释你所有的测试结果。

最后，

let clampedString0 = aThroughHHalfOpen.clamp ( tThroughXHalfOpen )

是空间隔，因为"A"..<"H"和"T"..<"X"没有共同点。对于任何，HalfOpenInterval(dummy, dummy)可以表示空间隔价值dummy。

字符串间隔如何工作？

1 个答案: