• Swift 字符串比较/判断

    2017-02-21 13:09:40
    Swift3.0语言教程比较、判断字符串 Swift3.0语言教程比较、判断字符串,在一个程序中字符串很多时,常常会做的操作就是对这些字符串进行比较和判断。本小节将讲解这些内容。 1.不区分大小写比较 字符串比较可以...

    Swift3.0语言教程比较、判断字符串

    Swift3.0语言教程比较、判断字符串,在一个程序中字符串很多时,常常会做的操作就是对这些字符串进行比较和判断。本小节将讲解这些内容。

    1.不区分大小写比较

    字符串比较可以分为:不区分大小写比较、区分大小写比较以及本地化比较三部分。首先我们来看不区分大小写比较,不区分大小写比较顾名思义就是不区分字符串中字母的大小写,即A和a相同。在NSString中使用caseInsensitiveCompare(_:)方法实现这一功能,其语法形式如下:

    func caseInsensitiveCompare(_ string: String) -> ComparisonResult

    其中,string用来指定一个比较的字符串。该方法的返回值为ComparisonResult类型。ComparisonResult是一个枚举类型,包含了以下3个成员:

    q  orderedAscending(-1):左操作数小于右操作数。

    q  orderedSame(0):两个操作数相等。

    q  orderedDescending(1):左操作数大于右操作数。

    【示例1-29】以下将使用caseInsensitiveCompare(_:)方法对字符串进行比较。

    import Foundation

    var a=NSString(string:"Hello")

    var b=NSString(string:"hello")

    var c=NSString(string:"Swift")

    //比较字符串

    print(a.caseInsensitiveCompare(b as String).rawValue)

    print(a.caseInsensitiveCompare(c as String).rawValue)

    print(c.caseInsensitiveCompare(a as String).rawValue)

    运行结果如下:

    0

    -1

    1

    2.区分大小写比较

    有不区分大小写比较,相对的就有区分大小写比较。在NSString中提供了4种方法实现了这种比较,分别为compare(_:)、compare(_:options:)、compare(_:options:range:)和compare(_:options:range:locale:)方法。

    (1)compare(_:)方法就是用来比较字符串的,它需要区分字符串的大小写,其语法形式如下:

    func compare(_ string: String) -> ComparisonResult

    其中,string用来指定一个比较的字符串。

    【示例1-30】以下将使用compare(_:)方法实现字符串的比较。

    import Foundation

    var a=NSString(string:"Hello")

    var b=NSString(string:"hello")

    var c=NSString(string:"Hello")

    //比较字符串

    print(a.compare(b as String).rawValue)

    print(a.compare(c as String).rawValue)

    print(b.compare(a as String).rawValue)

    运行结果如下:

    -1

    0

    1

    (2)compare(_:options:)方法和compare(_:)方法实现的功能类似,它是对字符串进行比较,但是它比compare(_:)方法多了一个mask参数。该参数可以用来指定一个选项标记(这个标记可以作为字符串比较的条件)。在编程中,mask参数最常被设置为以下5种:

    q  caseInsensitive:不区分大小写比较

    q  literal:区分大小写比较

    q  backwards:从字符串末尾开始搜索

    q  anchored:搜索限制范围的字符串

    q  numeric:按照字符串里的数字为依据,算出顺序。例如 Foo2.txt < Foo7.txt < Foo25.txt

    compare(_:options:)方法的语法形式如下:

    func compare(_ string: String, options mask: NSString.CompareOptions = []) -> ComparisonResul

    【示例1-31】以下将使用compare(_:options:)方法实现对字符串的比较。

    import Foundation

    var a=NSString(string:"Hello")

    var b=NSString(string:"hello")

    print(a.compare(b as String, options: NSString.CompareOptions.caseInsensitive).rawValue)    //比较字符串

    运行结果如下:

    0

    (3)compare(_:options:range:)方法和compare(_:options:)方法的功能类似,但是它比compare(_:options:)方法多了一个rangeOfReceiverToCompare参数,此参数可以用来对比较范围进行设置。其语法形式如下:

    func compare(_ string: String, options mask: NSString.CompareOptions = [], range rangeOfReceiverToCompare: NSRange) -> ComparisonResult

    【示例1-32】以下将使用compare(_:options:range:)方法对字符串进行比较。

    import Foundation

    var a=NSString(string:"HEllo")

    var b=NSString(string:"Swift")

    print(a.compare(b as String, options: NSString.CompareOptions.caseInsensitive,range: NSMakeRange(1, 3)).rawValue)                                                                                   //比较字符串

    运行结果如下:

    -1

    (4)compare(_:options:range:locale:)方法和compare(_:options:range:)方法的功能类似,但是它比compare(_:options:range:)方法多了一个locale参数,此参数可以用来设置语言环境。其语法形式如下:

    func compare(_ string: String, options mask: NSString.CompareOptions = [], range rangeOfReceiverToCompare: NSRange, locale: AnyObject?) -> ComparisonResult

    【示例1-33】以下将使用compare(_:options:range:locale:)方法对字符串进行比较。

    import Foundation

    var a=NSString(string:"a")

    var b=NSString(string:"ä")

    var l=Locale.current

    print(a.compare(b as String, options: NSString.CompareOptions.caseInsensitive, range: NSMakeRange(0, 1), locale: l).rawValue)

    运行结果如下:

    -1

    3.本地化比较

    对于本地化比较在NSString中提供了3种方法,分别为:localizedCaseInsensitiveCompare(_:)、localizedStandardCompare(_:)和localizedCompare(_:)。

    (1)localizedCaseInsensitiveCompare(_:)方法为不区分大小写、本地化比较字符串,其语法形式如下:

    func localizedCompare(_ string: String) -> ComparisonResult

    其中,string用来指定一个比较的字符串。

    【示例1-34】以下将使用localizedCaseInsensitiveCompare(_:)方法比较字符串。

    import Foundation

    var a=NSString(string:"Hello")

    var b=NSString(string:"hello")

    var c=NSString(string:"Swift")

    //比较字符串

    print(a.localizedCaseInsensitiveCompare(b as String).rawValue)

    print(a.localizedCaseInsensitiveCompare(c as String).rawValue)

    print(c.localizedCaseInsensitiveCompare(a as String).rawValue)

    运行结果如下:

    0

    -1

    1

    (2)localizedStandardCompare(_:)方法为本地化标准字符串的比较,其语法形式如下:

    func localizedStandardCompare(_ string: String) -> ComparisonResult

    其中,string用来指定一个比较的字符串。

    【示例1-35】以下将使用localizedStandardCompare(_:)方法实现字符串的比较。

    import Foundation

    var a=NSString(string:"Hello")

    var b=NSString(string:"hello")

    print(a.localizedStandardCompare(b as String).rawValue)                                         //比较字符串

    运行结果如下:

    1

    (3)localizedCompare(_:)方法是区分大小写、本地化比较字符串,其语法形式如下:

    func localizedCompare(_ string: String) -> ComparisonResult

    其中,string用来指定一个比较的字符串。

    【示例1-36】以下将使用localizedCompare(_:)方法实现对字符串的比较。

    import Foundation

    var a=NSString(string:"Hello")

    var b=NSString(string:"hello")

    var c=NSString(string:"Hello")

    print(a.localizedCompare(b as String).rawValue)

    print(a.localizedCompare(c as String).rawValue)

    print(b.localizedCompare(a as String).rawValue)

    运行结果如下:

    1

    0

    -1

    4.判断字符串

    在NSString中提供了3种对字符串判断的方法,分别为hasPrefix(_:)、hasSuffix(_:)和isEqual(to:)方法。

    (1)hasPrefix(_:)方法用来判断字符串是否以某一指定字符串开头,其语法形式如下:

    func hasPrefix(_ str: String) -> Bool

    其中,str用来指定一个字符串。

    【示例1-37】以下将判断字符串a是否以"H"、"Hel"和"Hele"开头。

    import Foundation

    var a=NSString(string:"Hello")

    //判断字符串a是否以"H"开头

    if(a.hasPrefix("H")){

        print("a字符串是以H开头的")

    }else{

        print("a字符串不是以H开头的")

    }

    //判断字符串a是否以"Hel"开头

    if(a.hasPrefix("Hel")){

        print("a字符串是以Hel开头的")

    }else{

        print("a字符串不是以Hel开头的")

    }

    //判断字符串a是否以"Hele"开头

    if(a.hasPrefix("Hele")){

        print("a字符串是以Hele开头的")

    }else{

        print("a字符串不是以Hele开头的")

    }

    运行结果如下:

    a字符串是以H开头的

    a字符串是以Hel开头的

    a字符串不是以Hele开头的

    (2)hasSuffix(_:)方法正好和hasPrefix(_:)方法相反,它是用来判断字符串是否以某一指定字符串结尾的,其语法形式如下:

    func hasSuffix(_ str: String) -> Bool

    其中,str用来指定一个字符串。

    【示例1-38】以下将判断字符串a是否以"o"、"Hello"、"allo"结尾。

    import Foundation

    var a=NSString(string:"Hello")

    //判断字符串a是否以"o"结尾。

    if(a.hasSuffix("o")){

        print("a字符串是以o结尾的")

    }else{

        print("a字符串不是以o结尾的")

    }

    //判断字符串a是否以"Hello"结尾。

    if(a.hasSuffix("Hello")){

        print("a字符串是以Hello结尾的")

    }else{

        print("a字符串不是以Hello结尾的")

    }

    //判断字符串a是否以"allo"结尾。

    if(a.hasSuffix("allo")){

        print("a字符串是以allo结尾的")

    }else{

        print("a字符串不是以allo结尾的")

    }

    运行结果如下:

    a字符串是以o结尾的

    a字符串是以Hello结尾的

    a字符串不是以allo结尾的

    (3)isEqual(to:)方法是用来判断字符串是否相等的,其语法形式如下:

    func isEqual(to aString: String) -> Bool

    其中,aString用来指定字符串。

    【示例1-39】以下将判断字符串是否相等。

    import Foundation

    var  a=NSString(string:"Hello")

    var  b=NSString(string:"hello")

    var  c=NSString(string:"Swift")

    var  d=NSString(string:"Hello")

    //判断字符串a和b是否相等

    if(a.isEqual(to: b as String)){

        print("a、b两个字符串相等")

    }else{

        print("a、b两个字符串不相等")

    }

    //判断字符串a和c是否相等

    if(a.isEqual(to: c as String)){

        print("a、c两个字符串相等")

    }else{

        print("a、c两个字符串不相等")

    }

    //判断字符串a和d是否相等

    if(a.isEqual(to: d as String)){

        print("a、d两个字符串相等")

    }else{

        print("a、d两个字符串不相等")

    }

    运行结果如下:

    a、b两个字符串不相等

    a、c两个字符串不相等

    a、d两个字符串相等

    展开全文
  • Swift字符串类型与Foundation的NSString类连接。Foundation还扩展了字符串来公开由NSString定义的方法。这意味着,如果您导入Foundation,您可以在字符串中访问这些NSString方法,而不需要进行强制转换。 单行...

    Swift的字符串类型与Foundation的NSString类连接。Foundation还扩展了字符串来公开由NSString定义的方法。这意味着,如果您导入Foundation,您可以在字符串中访问这些NSString方法,而不需要进行强制转换。

    单行字符串

    let someString = "Some stirng"

    多行文本

    多行文本使用 """ 内容 """ 没错,就是三个引号开头,三个引号结尾。
    多行字符串文字包含了它的起始引号和结束引号之间的所有行

    
    let lyric = """
    那是你的眼神,明亮又美丽
    啊啊啊~~~
    """
    print(lyric)
    
    结果:
    那是你的眼神,明亮又美丽
    啊啊啊~~~
    

    好吧,这个我一开始以为只是在格式上可以写成多行,没想到结果就是多行,效果等同于\n,而且这样写法更加方便。
    还有就是当我们想在多行文本中想控制某行不换行,可以选择在某行的末尾写上 \ 那么下一行就不会换行了

    let lyric = """
    那是你的眼神,明亮又美丽\
    啊啊啊~~~
    """
    
    结果:
    那是你的眼神,明亮又美丽啊啊啊~~~
    

    在多行文本中,我们可以在结束引号的前面设定空格,来限定整段文本的缩进:

    let lyric = """
      那是你的眼神,明亮又美丽
      啊啊啊~~~
    
      """
    

    上面例子中,我们在最后"""前设定了2个空格,那么之前的文本必须都是缩进2个空格如果你这样写:

    let lyric = """
    那是你的眼神,明亮又美丽
    啊啊啊~~~
    
      """
    

    你会发现会报错Insufficient indentation of line in multi-line string literal 多行字符串文字的行缩不足

    字符串中特殊字符

    \(反斜杠)

    let test = "====\\===="
    结果:
    ====\====
    

    \t(水平选项卡)

    let test = "\t1\t2\t3"
    结果:
        1   2   3
    

    \n(换行符)

    let test = "\n1\n2\n3"
    结果:
    
    1
    2
    3
    

    \r(回车)

    let test = "\r1\r2\r3"
    结果:
    
    1
    2
    3
    

    从结果来看,\r和\n似乎没有区别,但既然存在即表示肯定是有区别的

    '\r'是回车,\r 使光标到行首. '\n'是换行,\n 使光标下移一格,通常敲一个回车键,即是回车,又是换行(\r\n)。Unix中每行结尾只有“<换行>”,即“\n”;Windows中每行结尾是“<换行><回车>”,即“\n\r”;Mac中每行结尾是“<回车>”

    一般遇到的情况是在解析Json字符串,网页数据,文件信息的时候会出现不同的应对.

    "(双引号)

    let test = "\"认识自己的无知是认识世界的最可靠的方法。——《随笔集》\""
    结果:
    "认识自己的无知是认识世界的最可靠的方法。——《随笔集》"
    

    '(单引号)

    let test = "\'曦\'"
    结果:
    '曦'
    

    Unicode 字符就直接采用官网的了

    let dollarSign = "\u{24}"        // $,  Unicode scalar U+0024
    let blackHeart = "\u{2665}"      // ♥,  Unicode scalar U+2665
    let sparklingHeart = "\u{1F496}" // ?, Unicode scalar U+1F496
    
    结果:
    $ ♥ ?
    

    空字符串

    我们来看一下如果定义一个空字符串:

    var emptyString = ""
    或者
    var emptyString = String()
    

    判断字符串是否为空:

    isEmpty 方法

    var emptyString = ""
    
    if emptyString.isEmpty {
      print("emptyStirng is empty")
    }
    
    

    字符串可变性

    var variableString = "Horse"
    variableString += " and carriage"
    
    结果:
    variableStrin:Horse and carriage
    
    let constantString = "Highlander"
    constantString += " and another Highlander"
    发生错误。
    Left side of mutating operator isn't mutable: 'constantString' is a 'let' constant
    变异操作符的左侧是不可改变的:“常量字符串”是一个“let”常量
    

    简单来说就是variableString 是变量,可以通过+操作符来追加字符串, constantString 为常量,不可修改。

    这个我不得不吐槽一下,官网的这个解释,不就是常量不可修改嘛,说什么可变性。

    字符串是值类型

    If you create a new String value, that String value is copied when it’s passed to a function or method, or when it’s assigned to a constant or variable. In each case, a new copy of the existing String value is created, and the new copy is passed or assigned, not the original version.
    如果您创建一个新的字符串值,那么当它传递给一个函数或方法时,或者当它被分配给一个常量或变量时,该字符串值将被复制。
    在不同情况下,都会创建一个现有字符串值的新副本,并分配新副本,而不是原始版本。

    Swift’s copy-by-default String behavior ensures that when a function or method passes you a String value, it’s clear that you own that exact String value, regardless of where it came from. You can be confident that the string you are passed won’t be modified unless you modify it yourself.
    Swift的 copy-by-default 行为可以确保当函数或方法传递给你一个字符串值时,不管它是从哪里来的,你都能清楚地知道你的值是什么。您可以确信,您所传递的字符串不会被修改,除非您自己修改它。

    Behind the scenes, Swift’s compiler optimizes string usage so that actual copying takes place only when absolutely necessary. This means you always get great performance when working with strings as value types.
    在后台,Swift的编译器优化了字符串的使用,所以只有在绝对必要的情况下才会进行实际的复制。这意味着在使用字符串作为值类型时,您总是获得很好的性能。

    这个就有别于OC了,OC中有明确的分为NSString(不可变)和NSMutableString(可变),swift中只有这么一种了,通过对此的优化更加确保了数据的安全。

    字符

    定义一个字符(Character)类型的常量charA

    let charA:Character = "A"
    print("charA:\(charA)")
    结果:
    charA:A
    

    您可以通过使用for循环遍历字符串来访问字符串的单个字符值:

    let character = ""
    let str = "窗外的麻雀"
    for character in str {
        print(character)
    }
    结果:
    窗
    外
    的
    麻
    雀
    

    创建一个字符值数组:

    let catCharacters: [Character] = ["C", "a", "t", "!", "?"]
    print(catCharacters)
    结果:
    ["C", "a", "t", "!", "?"]
    

    可以通过String(字符数组)来将字符数组转换成字符串

    let catCharacters: [Character] = ["C", "a", "t", "!", "?"]
    let catString = String(catCharacters)
    print(catString)
    结果:
    Cat!?
    

    字符串的连接:
    我们可以用 + 操作符连接字符串

    let string1 = "hello"
    let string2 = " there"
    var welcome = string1 + string2
    print("welcome \(welcome)")
    结果:
    welcome hello there
    

    除了+操作符之外,还有append方法

    let string1 = "hello"
    let string2 = " there"
    var welcome = string1 + string2
    
    let exclamationMark: Character = "!"
    welcome.append(exclamationMark)
    print("welcome \(welcome)")
    结果:
    welcome hello there!
    

    append是将字符串追加到原本字符串的末尾

    以上的添加方法是通过连接两个字符串的值形成一个新的值
    而在有的时候我们其实只需要临时的展示而已,不需要去改变原有的值,那么这个时候其实只需要这样做就可以了:

    let badStart = """
    one
    two
    """
    let end = """
    three
    """
    print(badStart + end)
    print(badStart)
    
    结果:
    one
    twothree
    
    one
    two
    

    可以看到我们在输出print中将其相加,虽然显示了,但其实badStart的结果并没有改变。

    字符串的插值

    在使用字符串的时候,我们可能需要利用其它的变量来改变我们目前的数据,而这个时候我们可以使用 \(value) 来将我们需要的值

    let multiplier = 3
    let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
    
    结果:
    3 times 2.5 is 7.5
    

    当然了,这个也不是万能,它是不能将未转义的\直接放置于()中的:
    错误的方式

    let message = "\(\)"
    print(message)
    
    let message = "\(\')"
    print(message)
    
    

    正确的方式是这样的:

    let message = "\("\'")"
    print(message)
    结果:
    '
    

    计算字符的个数

    计算字符的个数是我们比较常用的方法count

    let unusualMenagerie = "Koala ?, Snail ?, Penguin ?, Dromedary ?"
    print("unusualMenagerie has \(unusualMenagerie.count) characters")
    结果:
    unusualMenagerie has 40 characters
    

    当然了,count并不总是能够计算清楚我们的字符个数:

    var word = "cafe"
    print("the number of characters in \(word) is \(word.count)")
    这个计算结果是4
    word += "\u{301}"  
    print("the number of characters in \(word) is \(word.count)")
    当我们计算的会发现结果仍然是4
    

    这是为什么呢?
    因为swift中的字符串运用了扩展字元簇(Extended Grapheme Clusters)

    扩展字元簇可以由多个Unicode标量组成。
    这意味着不同的字符和相同字符的不同表示可以要求不同的内存数量来存储。
    因此,Swift中的字符不会在字符串的表示中占用相同数量的内存。

    结果,字符串中的字符数无法计算.
    如果您使用的是特别长的字符串值,请注意,count属性必须遍历整个字符串中的Unicode标量,以便确定该字符串的字符。

    比如:字母é可以是一个单独的Unicode scalar:U+00E9,也可以是多个纯量的组合:U+0065U+0301 (其中U+0065就是字母e)。在Swift中,这两种情况都认为是一个字符,因此获取字符串长度的时候(用全局函数count()),返回的值是相同的,这意味着字符串的改变并不一定意味着其长度发生变化。

    count属性返回的字符数并不总是与包含相同字符的NSString的长度属性相同。
    NSString的length是基于字符串的utf-16表示的16位代码单元的数量,而不是字符串中Unicode扩展的grapheme集群的数量

    字符串索引

    let greeting = "Guten Tag!"
    //字符串中的开头字母
    print(greeting[greeting.startIndex])
    //index()表示获取字符串中某个下标的元素,before意味着获取最后一位的之前的下标
    //endIndex表示字符串最后一位
    print(greeting[greeting.index(before: greeting.endIndex)])
    //after表示获取某个下标之后
    print(greeting[greeting.index(after: greeting.startIndex)])
    //这个方法表示以startIndex下标开始,偏移7位
    let index = greeting.index(greeting.startIndex, offsetBy: 7)
    print(greeting[index])
    结果:
    G
    !
    u
    a
    

    使用索引属性来访问字符串中各个字符的所有索引:

    for index in greeting.indices {
        print("\(greeting[index]) ", terminator: "")
    }
    结果:
    G u t e n   T a g ! 
    

    这里的terminator是print方法中参数,默认是添加换行符\n

    let greeting = "Guten Tag!"
    
    for index in greeting.indices {
        print("\(greeting[index]) ", terminator: "\n")
    }
    G 
    u 
    t 
    e 
    n 
      
    T 
    a 
    g 
    ! 
    

    感觉跟print没有区别吧。

    let greeting = "Guten Tag!"
    
    for index in greeting.indices {
        print("\(greeting[index]) ", terminator: "1")
    }
    结果:
    G 1u 1t 1e 1n 1  1T 1a 1g 1! 1
    

    这个其实就是在每次获取单个字符之后添加一个字符。

    字符串的插入和删除

    插入

    insert(value,at:index)

    var welcome = "hello"
    welcome.insert("!", at:welcome.endIndex)
    print(welcome)
    结果:
    hello!
    
    var welcome = "hello!"
    welcome.insert(contentsOf: " world", at: welcome.index(before: welcome.endIndex))
    print(welcome)
    结果:
    hello world!
    

    移除

    remove(at:index)
    根据下标进行移除

    removeSubrange
    根据提供的范围进行移除

    var welcome = "hello!"
    welcome.remove(at: welcome.index(before: welcome.endIndex))
    print(welcome)
    结果:
    hello
    
    var welcome = "hello world"
    //空格的位置 - 末尾
    let range = welcome.index(welcome.endIndex, offsetBy: -6)..<welcome.endIndex
    welcome.removeSubrange(range)
    print(welcome)
    结果:
    hello 
    

    后续更新,敬请期待...



    作者:如风如花不如你
    链接:https://www.jianshu.com/p/87c29641db61
    来源:简书
    简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。

    展开全文
  • swift字符串的处理

    2016-06-21 17:40:12
    今天总结下swift中对于字符串的操作,记录下工作中常用的。。。 1、字符串的声明  关于字符串的声明可以标注类型,也可以不标注,如 // 1、字符串声明 var emptyStr : String = " "//声明一个空字符串 var str : ...

    今天总结下swift中对于字符串的操作,记录下工作中常用的。。。

    1、字符串的声明

     关于字符串的声明可以标注类型,也可以不标注,如

    //        1、字符串声明
            var emptyStr : String = " "//声明一个空字符串
            var str : String = "Hello World"//定义变量类型为String
            var str1 = "Hello World"//未定义变量类型,在swift中会根据值推测变量的类型为String
           
            
            //判断字符串是否为空,若为空则为true,否则为false
            let bool : Bool = emptyStr.isEmpty
    
    判断字符串是否为空,除了上面这个方法,还有一种笨办法:在定义变量类型时允许变量为空,则可以使用 xx == nil 的方式来判断

     var str3 : String?
            if str3 == nil {
                str3 = "Hello World"
            }
    

    其中代码中的“ ? ”表示该变量是一个可选值Optional,其值可以为nil,也可以有具体的值。一旦声明为可选值,如果没有指定值,默认是nil,可用if进行该字符串是否有值的判断


    2、字符串的拼接

    字符串的连接主要有两种方式:一种是直接在字符串后面添加字符串,另一种是将字符串数组拼接成一个字符串

    //        2、字符串拼接
            let str = "Hello"
            let str2 = "world"
            let str3 = str + str2//利用+直接将字符串拼接在一起,比较直接
            
            let array : [String] = ["aaa","bbb", "ccc"]
            let arrayStr : String = array.joinWithSeparator("/")//将数组中的元素拼接成字符串
    其拼接的结果如下
    str3 Helloworld
    arrayStr aaa/bbb/ccc
    


    3、字符串的截取

    字符串的截取是利用substringFromIndex、substringToIndex、substringWithRange这三个函数

    <pre name="code" class="objc">//        3、字符串的截取
            let str = "Hello World"
            //substringFromIndex:是包括当前下标的值开始截取,到字符串最后停止
            let ns1=str.substringFromIndex(str.startIndex.successor())
            
            //substringToIndex:是截取到当前下标为止
            let ns2=str.substringToIndex(str.endIndex.predecessor())
            
            //substringWithRange: 截取指定范围内的字符串
            let start = str.startIndex.advancedBy(2)
            let end = str.startIndex.advancedBy(7)
            let ns3=str.substringWithRange(Range(start: start, end: end))
    </pre><p></p><pre>
    截取的结果为:

    ns1  ello World
    ns2  Hello Worl
    ns3  llo W

    4、字符串的访问

    字符串的访问可以通过下标来访问。主要有四种方式,分别为:

        startIndex:表示字符串开始的下标

        endIndex:表示字符串结束的下标

        successor:用于上面两个下标调用,表示在原本下标的基础上+1,也就是下一个

        predecessor:也是用于上面两下标调用,表示在原本下标的基础上-1,也就是前一个或上一个

     <pre name="code" class="objc"> let str = "Hello World"
            
            /*startIndex代表字符串开始的下标*/
            str[str.startIndex]
            
            /*endIndex代表字符串结束的下面    predecessor代表前一个*/
            str[str.endIndex.predecessor()]
            
            /*successor表示继续的也就是下一个*/
            str[str.startIndex.successor()]
            
            /*字符串不支持直接访问下标,需要使用advance函数转化,如果访问的下标超出字符串就会发出运行时错误*/
            let index = str.startIndex.advancedBy(7)
            str[index]
    

    
    

    特别注意的是,在swift中的字符串不能直接访问下标,需要通过advance函数将下标值转换,主要原因是OC中下标的类型是Int,而在swift中,下标的类型是Index类型

    运行结果如下:

    str[str.startIndex] H
    str[str.endIndex.predecessor()] d
    str[str.startIndex.successor()] e
    str[index] o
    

    5、字符串的比较

    字符串的比较主要包括三个方面:是否相等用“==”,xxx字符串开头是否包含xx用hasPrefix,xxx字符串结尾是否包括xx用hasSuffix。代码如下:

    // 5 、字符串的比较
            let str = "Hello"
            let str1 = "World"
              //比较两个字符串是否相等
            if str1 == str {
                print("str1 和 str 相等")
            }else{
                print("str1 和 str 不相等")
            }
        
                
                //判断字符串开头是否包含he
                if(str.hasPrefix("He")) {
                    print("str 开头包含 He");
            }
            
                    //判断字符串结尾是否包含ng
            if(str1.hasSuffix("ld")) {
                print("str1 结尾包含 ld");
            }
    


    6、其他操作

    字符串的其他操作是指过滤和替换

    //        6、其他操作
            //过滤单个字符
            var url = "http://cnews.chinadaily.com.cn/2016-06/21/content_25783045.htm"
            var filtered = url.stringByReplacingOccurrencesOfString("/", withString: "", options: NSStringCompareOptions.LiteralSearch, range: nil)
            print("filtered \(filtered)")
            
            //替换 将/替换为?
            url = "http://cnews.chinadaily.com.cn/2016-06/21/content_25783045.htm"
            
             filtered = url.stringByReplacingOccurrencesOfString("/", withString: "?", options: NSStringCompareOptions.LiteralSearch, range: nil)
            print("filtered \(filtered)")
    
    其结果为:

    filtered http:cnews.chinadaily.com.cn2016-0621content_25783045.htm
    filtered http:??cnews.chinadaily.com.cn?2016-06?21?content_25783045.htm



       

    展开全文
  • OC与Swift中的字符串

    2019-02-20 00:37:46
    一般情况下,使用一个旧的字符串对象对一个新声明的字符串对象进行赋值,其实就是新的指针指向同一个字符串对象,也就是指针的拷贝,并没有生成新的字符串。只有对一个可变字符串对象进行拷贝,或者对任意字符串对象...

    一、OC中的字符串

    1. 引用类型

      在Object-C中,使用NSString和NSMutableString这两个类对字符串进行操作,一个字符串对象会被指针所引用。

      一般情况下,使用一个旧的字符串对象对一个新声明的字符串对象进行赋值,其实就是新的指针指向同一个字符串对象,也就是指针的拷贝,并没有生成新的字符串。只有对一个可变字符串对象进行拷贝,或者对任意字符串对象进行可变拷贝时才会生成一个新对象。

      同样的在函数、方法传值时,也是指针的传递,操作的都是同一份对象。

    2. 可变与不可变字符串

      NSString类型的对象是不可变字符串,NSString一旦被实例化,就不能再改变内容和长度。

      NSMutableString类型的对象是可变字符串,它可以进行拼接、移除、插入等操作。

    3. 常用字符串操作

    • 新建字符串
    // 创建一个空字符串
    NSString *str1 = [NSString string];
    NSString *str2 = @"";
        
    // 创建一个非空串
    NSString *str3 = @"我是一个字符串";
    
    • 是否空串
    NSString *name = @"";
    if (name.length == 0) {
        NSLog(@"名字是个空字符串");
    } else {
        NSLog(@"名字不是个空字符串");
    }
    
    • 长度
    name = @"Alean";
    NSInteger nameLength = name.length;
    NSLog(@"姓名长度:%zd个字符", nameLength);
    
    • 是否相同
    NSString *name2 = @"Alean";
    if ([name isEqualToString:name2]) {
        NSLog(@"姓名相同");
    } else {
        NSLog(@"姓名不同");
    }
    
    • 大小写转换
    NSString *upperName = name.uppercaseString;
    NSString *lowerName = name.lowercaseString;
    NSLog(@"姓名大写:%@ \n姓名小写:%@", upperName, lowerName);
    
    • 开头
    NSString *prefix = @"Ale";
    if ([name hasPrefix:prefix]) {
        NSLog(@"%@是以%@开头的", name, prefix);
    } else {
        NSLog(@"%@不是以%@开头的", name, prefix);
    }
    
    • 结尾
    NSString *suffix = @"na";
    if ([name hasSuffix:suffix]) {
        NSLog(@"%@是以%@结尾的", name, suffix);
    } else {
        NSLog(@"%@不是以%@结尾的", name, suffix);
    }
    
    • 从头截取子串
    NSInteger indexTo = 2;
    NSString *subNameTo = [name substringToIndex:indexTo];
    NSLog(@"%@从开头截取%@个字符的子串%@", name, @(indexTo), subNameTo);
    
    • 从指定位置截取子串
    NSInteger indexFrom = 3;
    NSString *subNameFrom = [name substringFromIndex:indexFrom];
    NSLog(@"%@从第%@个字符到结束的子串%@", name, @(indexFrom), subNameFrom);
    
    • 指定区间子串
    NSRange range = NSMakeRange(1, 2);
    NSString *subNameRange = [name substringWithRange:range];
    NSLog(@"%@从第%zd个字符截取长度为%zd的子串为%@", name, range.location, range.length, subNameRange);
    
    • 拼接
    NSString *all = [name stringByAppendingString:name2];
    NSLog(@"%@拼接%@的结果是:%@", name, name2, all);
    

    二、swift中的字符串

    1. 引用类型

      Swift中,String类型对象一个实际的值,使用旧的String对象对新定义的String赋值,实际创建了一个相等的新值。

      同样,函数传参时,也是传递的实际值,并且创建了一个新的字符串,函数内的操作不会改变原有的String对象。

    2. 可变与不可变字符串

      Swift中可变字符串使用var修饰,let用来修饰不可变字符串。

    3. 常用字符串操作

    • 创建一个空字符串
    let emptyStr1 = ""
    let emptyStr2 = String()
    
    • 创建字符串常量
    let nameConst = "Jack"
    
    • 创建字符串变量
    var nameVariable = "xiaoming"
    nameVariable = "xiaogang"
    
    • 是否空串
    var name = ""
    if name.isEmpty {
        print("名字是个空字符串")
    } else {
        print("名字叫:\(name)")
    }
    

    // 长度
    name = “Alean”
    let nameLength = name.characters.count
    print(“姓名长度:(nameLength)个字符”)

    • 是否相同
    let name2 = "Alean"
    if name == name2 {
        print("姓名相同")
    } else {
        print("姓名不同")
    }
    
    • 大小写转换
    let upperName = name.uppercased()
    let lowerName = name.lowercased()
    print("姓名大写:\(upperName) \n姓名小写:\(lowerName)")
    
    • 开头
    let prefix = "Ale"
    if name.hasPrefix(prefix) {
        print("\(name)是以\(prefix)开头的")
    } else {
        print("\(name)不是以\(prefix)开头的")
    }
    
    • 结尾
    let suffix = "na"
    if name.hasSuffix(suffix) {
        print("\(name)是以\(suffix)结尾的")
    } else {
        print("\(name)不是以\(suffix)结尾的")
    }
    
    • 从头截取子串
    let indexTo = 2
    let subIndexTo = name.index(name.startIndex, offsetBy: indexTo)
    let subNameTo = name.substring(to: subIndexTo)
    print("\(name)从开头截取\(indexTo)个字符的子串\(subNameTo)")
    
    • 从指定位置截取子串
    let indexFrom = -2
    let fromIndexFrom = name.characters.count + indexFrom
    let subIndexFrom = name.index(name.endIndex, offsetBy: indexFrom)
    let subNameFrom = name.substring(from: subIndexFrom)
    print("\(name)从第\(fromIndexFrom)个字符到结束的子串\(subNameFrom)")
    
    • 指定区间子串
    let subFormIndex = 1
    let subLength = 2
    let rangeStartIndex = name.index(name.startIndex, offsetBy: subFormIndex)
    let rangeLengthIndex = name.index(name.startIndex, offsetBy: subFormIndex + subLength)
    let range = Range(uncheckedBounds: (lower: rangeStartIndex, upper: rangeLengthIndex))
    let subNameRange = name.substring(with: range)
    print("\(name)从第\(subFormIndex)个字符截取长度为\(subLength)的子串为\(subNameRange)")
    
    • 拼接
    let all = name + name2
    print("\(name)拼接\(name2)的结果是:\(all)")
    
    展开全文
  • swift字符串和字符

    2018-12-18 10:16:20
    2.3、字符串和字符(Strings and Characters) 本页包含内容: 字符串字面量 初始化空字符串 字符串可变性 字符串是值类型 使用字符 连接字符串和字符 字符串插值 Unicode 计算字符数量 访问和修改字符串 比较字符...

     

    2.3、字符串和字符(Strings and Characters)

    本页包含内容:

    字符串字面量
    初始化空字符串
    字符串可变性
    字符串是值类型
    使用字符
    连接字符串和字符
    字符串插值
    Unicode
    计算字符数量
    访问和修改字符串
    比较字符串
    字符串的 Unicode 表示形式

    字符串是例如"hello, world""albatross"这样的有序的Character(字符)类型的值的集合。通过String类型来表示。 一个String的内容可以用许多方式读取,包括作为一个Character值的集合。

    Swift 的StringCharacter类型提供了快速和兼容 Unicode 的方式供你的代码使用。创建和操作字符串的语法与 C 语言中字符串操作相似,轻量并且易读。 字符串连接操作只需要简单地通过+符号将两个字符串相连即可。与 Swift 中其他值一样,能否更改字符串的值,取决于其被定义为常量还是变量。你也可以在字符串内插过程中使用字符串插入常量、变量、字面量表达成更长的字符串,这样可以很容易的创建自定义的字符串值,进行展示、存储以及打印。

    尽管语法简易,但String类型是一种快速、现代化的字符串实现。 每一个字符串都是由编码无关的 Unicode 字符组成,并支持访问字符的多种 Unicode 表示形式(representations)。

    注意:
    Swift 的String类型与 Foundation NSString类进行了无缝桥接。Foundation 也可以对String进行扩展,暴露在NSString中定义的方法。 这意味着,如果你在String中调用这些NSString的方法,将不用进行转换。
     

    字符串字面量

    您可以在您的代码中包含一段预定义的字符串值作为字符串字面量。字符串字面量是由双引号 ("") 包裹着的具有固定顺序的文本字符集。 字符串字面量可以用于为常量和变量提供初始值:

    let someString = "Some string literal value"
    

    注意someString常量通过字符串字面量进行初始化,Swift 会推断该常量为String类型。

    注意: 更多关于在字符串字面量中使用特殊字符的信息,请查看 字符串字面量的特殊字符。

    初始化空字符串

    要创建一个空字符串作为初始值,可以将空的字符串字面量赋值给变量,也可以初始化一个新的String实例:

    var emptyString = ""               // 空字符串字面量
    var anotherEmptyString = String()  // 初始化方法
    // 两个字符串均为空并等价。
    

    您可以通过检查其Bool类型的isEmpty属性来判断该字符串是否为空:

    if emptyString.isEmpty {
        print("Nothing to see here")
    }
    // 打印输出:"Nothing to see here"
    

    字符串可变性

    您可以通过将一个特定字符串分配给一个变量来对其进行修改,或者分配给一个常量来保证其不会被修改:

    var variableString = "Horse"
    variableString += " and carriage"
    // variableString 现在为 "Horse and carriage"
    
    let constantString = "Highlander"
    constantString += " and another Highlander"
    // 这会报告一个编译错误 (compile-time error) - 常量字符串不可以被修改。
    

    注意:
    在 Objective-C 和 Cocoa 中,您需要通过选择两个不同的类(NSStringNSMutableString)来指定字符串是否可以被修改。

    字符串是值类型

    Swift 的String类型是值类型。 如果您创建了一个新的字符串,那么当其进行常量、变量赋值操作,或在函数/方法中传递时,会进行值拷贝。 任何情况下,都会对已有字符串值创建新副本,并对该新副本进行传递或赋值操作。 值类型在 结构体和枚举是值类型 中进行了详细描述。

    Swift 默认字符串拷贝的方式保证了在函数/方法中传递的是字符串的值。 很明显无论该值来自于哪里,都是您独自拥有的。 您可以确信传递的字符串不会被修改,除非你自己去修改它。

    在实际编译时,Swift 编译器会优化字符串的使用,使实际的复制只发生在绝对必要的情况下,这意味着您将字符串作为值类型的同时可以获得极高的性能。

    使用字符

    您可通过for-in循环来遍历字符串中的characters属性来获取每一个字符的值:

    for character in "Dog!?".characters {
        print(character)
    }
    // D
    // o
    // g
    // !
    // ?
    

    for-in循环在 for循环 中进行了详细描述。

    另外,通过标明一个Character类型并用字符字面量进行赋值,可以建立一个独立的字符常量或变量:

    let exclamationMark: Character = "!"
    

    字符串可以通过传递一个值类型为Character的数组作为自变量来初始化:

    let catCharacters: [Character] = ["C", "a", "t", "!", "?"]
    let catString = String(catCharacters)
    print(catString)
    // 打印输出:"Cat!?"
    

    连接字符串和字符

    字符串可以通过加法运算符(+)相加在一起(或称“连接”)创建一个新的字符串:

    let string1 = "hello"
    let string2 = " there"
    var welcome = string1 + string2
    // welcome 现在等于 "hello there"
    

    您也可以通过加法赋值运算符 (+=) 将一个字符串添加到一个已经存在字符串变量上:

    var instruction = "look over"
    instruction += string2
    // instruction 现在等于 "look over there"
    

    您可以用append()方法将一个字符附加到一个字符串变量的尾部:

    let exclamationMark: Character = "!"
    welcome.append(exclamationMark)
    // welcome 现在等于 "hello there!"
    

    注意:
    您不能将一个字符串或者字符添加到一个已经存在的字符变量上,因为字符变量只能包含一个字符。

    字符串插值

    字符串插值是一种构建新字符串的方式,可以在其中包含常量、变量、字面量和表达式。 您插入的字符串字面量的每一项都在以反斜线为前缀的圆括号中:

    let multiplier = 3
    let message = "\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"
    // message 是 "3 times 2.5 is 7.5"
    

    在上面的例子中,multiplier作为\(multiplier)被插入到一个字符串常量量中。 当创建字符串执行插值计算时此占位符会被替换为multiplier实际的值。

    multiplier的值也作为字符串中后面表达式的一部分。 该表达式计算Double(multiplier) * 2.5的值并将结果 (7.5) 插入到字符串中。 在这个例子中,表达式写为\(Double(multiplier) * 2.5)并包含在字符串字面量中。

    注意:
    插值字符串中写在括号中的表达式不能包含非转义反斜杠 (\),并且不能包含回车或换行符。不过,插值字符串可以包含其他字面量。

    Unicode

    Unicode是一个国际标准,用于文本的编码和表示。 它使您可以用标准格式表示来自任意语言几乎所有的字符,并能够对文本文件或网页这样的外部资源中的字符进行读写操作。 Swift 的StringCharacter类型是完全兼容 Unicode 标准的。

    Unicode 标量

    Swift 的String类型是基于 Unicode 标量 建立的。 Unicode 标量是对应字符或者修饰符的唯一的21位数字,例如U+0061表示小写的拉丁字母(LATIN SMALL LETTER A)("a"),U+1F425表示小鸡表情(FRONT-FACING BABY CHICK) ("?")。

    注意: Unicode 码位(code poing) 的范围是U+0000U+D7FF或者U+E000U+10FFFF。Unicode 标量不包括 Unicode 代理项(surrogate pair) 码位,其码位范围是U+D800U+DFFF

    注意不是所有的21位 Unicode 标量都代表一个字符,因为有一些标量是留作未来分配的。已经代表一个典型字符的标量都有自己的名字,例如上面例子中的LATIN SMALL LETTER AFRONT-FACING BABY CHICK

    字符串字面量的特殊字符

    字符串字面量可以包含以下特殊字符:

    • 转义字符\0(空字符)、\\(反斜线)、\t(水平制表符)、\n(换行符)、\r(回车符)、\"(双引号)、\'(单引号)。
    • Unicode 标量,写成\u{n}(u为小写),其中n为任意一到八位十六进制数且可用的 Unicode 位码。

    下面的代码为各种特殊字符的使用示例。 wiseWords常量包含了两个双引号。dollarSignblackHeartsparklingHeart常量演示了三种不同格式的 Unicode 标量:

    let wiseWords = "\"Imagination is more important than knowledge\" - Einstein"
    // "Imageination is more important than knowledge" - Enistein
    let dollarSign = "\u{24}"             // $, Unicode 标量 U+0024
    let blackHeart = "\u{2665}"           // ♥, Unicode 标量 U+2665
    let sparklingHeart = "\u{1F496}"      // ?, Unicode 标量 U+1F496
    

    可扩展的字形群集

    每一个 Swift 的Character类型代表一个可扩展的字形群。 一个可扩展的字形群是一个或多个可生成人类可读的字符 Unicode 标量的有序排列。
    举个例子,字母é可以用单一的 Unicode 标量é(LATIN SMALL LETTER E WITH ACUTE, 或者U+00E9)来表示。然而一个标准的字母e(LATIN SMALL LETTER E或者U+0065) 加上一个急促重音(COMBINING ACTUE ACCENT)的标量(U+0301),这样一对标量就表示了同样的字母é。 这个急促重音的标量形象的将e转换成了é

    在这两种情况中,字母é代表了一个单一的 Swift 的Character值,同时代表了一个可扩展的字形群。 在第一种情况,这个字形群包含一个单一标量;而在第二种情况,它是包含两个标量的字形群:

    let eAcute: Character = "\u{E9}"                         // é
    let combinedEAcute: Character = "\u{65}\u{301}"          // e 后面加上  ́
    // eAcute 是 é, combinedEAcute 是 é
    

    可扩展的字符群集是一个灵活的方法,用许多复杂的脚本字符表示单一的Character值。 例如,来自朝鲜语字母表的韩语音节能表示为组合或分解的有序排列。 在 Swift 都会表示为同一个单一的Character值:

    let precomposed: Character = "\u{D55C}"                  // 한
    let decomposed: Character = "\u{1112}\u{1161}\u{11AB}"   // ᄒ, ᅡ, ᆫ
    // precomposed 是 한, decomposed 是 한
    

    可拓展的字符群集可以使包围记号(例如COMBINING ENCLOSING CIRCLE或者U+20DD)的标量包围其他 Unicode 标量,作为一个单一的Character值:

    let enclosedEAcute: Character = "\u{E9}\u{20DD}"
    // enclosedEAcute 是 é⃝
    

    地域性指示符号的 Unicode 标量可以组合成一个单一的Character值,例如REGIONAL INDICATOR SYMBOL LETTER U(U+1F1FA)和REGIONAL INDICATOR SYMBOL LETTER S(U+1F1F8):

    let regionalIndicatorForUS: Character = "\u{1F1FA}\u{1F1F8}"
    // regionalIndicatorForUS 是 ??
    

    计算字符数量

    如果想要获得一个字符串中Character值的数量,可以使用字符串的characters属性的count属性:

    let unusualMenagerie = "Koala ?, Snail ?, Penguin ?, Dromedary ?"
    print("unusualMenagerie has \(unusualMenagerie.characters.count) characters")
    // 打印输出 "unusualMenagerie has 40 characters"
    

    注意在 Swift 中,使用可拓展的字符群集作为Character值来连接或改变字符串时,并不一定会更改字符串的字符数量。

    例如,如果你用四个字符的单词cafe初始化一个新的字符串,然后添加一个COMBINING ACTUE ACCENT(U+0301)作为字符串的结尾。最终这个字符串的字符数量仍然是4,因为第四个字符是é,而不是e

    var word = "cafe"
    print("the number of characters in \(word) is \(word.characters.count)")
    // 打印输出 "the number of characters in cafe is 4"
    
    word += "\u{301}"    // COMBINING ACUTE ACCENT, U+0301
    
    print("the number of characters in \(word) is \(word.characters.count)")
    // 打印输出 "the number of characters in café is 4"
    

    注意:
    可扩展的字符群集可以组成一个或者多个 Unicode 标量。这意味着不同的字符以及相同字符的不同表示方式可能需要不同数量的内存空间来存储。所以 Swift 中的字符在一个字符串中并不一定占用相同的内存空间数量。因此在没有获取字符串的可扩展的字符群的范围时候,就不能计算出字符串的字符数量。如果您正在处理一个长字符串,需要注意characters属性必须遍历全部的 Unicode 标量,来确定字符串的字符数量。

    另外需要注意的是通过characters属性返回的字符数量并不总是与包含相同字符的NSStringlength属性相同。NSStringlength属性是利用 UTF-16 表示的十六位代码单元数字,而不是 Unicode 可扩展的字符群集。

    访问和修改字符串

    你可以通过字符串的属性和方法来访问和修改它,当然也可以用下标语法完成。

    字符串索引

    每一个String值都有一个关联的索引(index)类型,String.Index,它对应着字符串中的每一个Character的位置。

    前面提到,不同的字符可能会占用不同数量的内存空间,所以要知道Character的确定位置,就必须从String开头遍历每一个 Unicode 标量直到结尾。因此,Swift 的字符串不能用整数(integer)做索引。

    使用startIndex属性可以获取一个String的第一个Character的索引。使用endIndex属性可以获取最后一个Character的后一个位置的索引。因此,endIndex属性不能作为一个字符串的有效下标。如果String是空串,startIndexendIndex是相等的。

    通过调用 String 的 index(before:) 或 index(after:) 方法,可以立即得到前面或后面的一个索引。您还可以通过调用 index(_:offsetBy:) 方法来获取对应偏移量的索引,这种方式可以避免多次调用 index(before:) 或 index(after:) 方法。

    你可以使用下标语法来访问 String 特定索引的 Character

    let greeting = "Guten Tag!"
    greeting[greeting.startIndex]
    // G
    greeting[greeting.index(before: greeting.endIndex)]
    // !
    greeting[greeting.index(after: greeting.startIndex)]
    // u
    let index = greeting.index(greeting.startIndex, offsetBy: 7)
    greeting[index]
    // a
    

    试图获取越界索引对应的 Character,将引发一个运行时错误。

    greeting[greeting.endIndex] // error
    greeting.index(after: endIndex) // error
    

    使用 characters 属性的 indices 属性会创建一个包含全部索引的范围(Range),用来在一个字符串中访问单个字符。

    for index in greeting.characters.indices {
       print("\(greeting[index]) ", terminator: "")
    }
    // 打印输出 "G u t e n   T a g ! "
    

    注意:
    您可以使用 startIndex 和 endIndex 属性或者 index(before:) 、index(after:) 和 index(_:offsetBy:) 方法在任意一个确认的并遵循 Collection 协议的类型里面,如上文所示是使用在 String 中,您也可以使用在 ArrayDictionary 和 Set中。

    插入和删除

    调用 insert(_:at:) 方法可以在一个字符串的指定索引插入一个字符,调用 insert(contentsOf:at:) 方法可以在一个字符串的指定索引插入一个段字符串。

    var welcome = "hello"
    welcome.insert("!", at: welcome.endIndex)
    // welcome 变量现在等于 "hello!"
    
    welcome.insert(contentsOf:" there".characters, at: welcome.index(before: welcome.endIndex))
    // welcome 变量现在等于 "hello there!"
    

    调用 remove(at:) 方法可以在一个字符串的指定索引删除一个字符,调用 removeSubrange(_:) 方法可以在一个字符串的指定索引删除一个子字符串。

    welcome.remove(at: welcome.index(before: welcome.endIndex))
    // welcome 现在等于 "hello there"
    
    let range = welcome.index(welcome.endIndex, offsetBy: -6)..<welcome.endIndex
    welcome.removeSubrange(range)
    // welcome 现在等于 "hello"
    

    注意: 您可以使用 insert(_:at:)insert(contentsOf:at:)remove(at:) 和 removeSubrange(_:) 方法在任意一个确认的并遵循 RangeReplaceableCollection 协议的类型里面,如上文所示是使用在 String 中,您也可以使用在 ArrayDictionary 和 Set 中。

    比较字符串

    Swift 提供了三种方式来比较文本值:字符串字符相等、前缀相等和后缀相等。

    字符串/字符相等

    字符串/字符可以用等于操作符(==)和不等于操作符(!=),详细描述在比较运算符:

    let quotation = "We're a lot alike, you and I."
    let sameQuotation = "We're a lot alike, you and I."
    if quotation == sameQuotation {
        print("These two strings are considered equal")
    }
    // 打印输出 "These two strings are considered equal"
    

    如果两个字符串(或者两个字符)的可扩展的字形群集是标准相等的,那就认为它们是相等的。在这个情况下,即使可扩展的字形群集是有不同的 Unicode 标量构成的,只要它们有同样的语言意义和外观,就认为它们标准相等。

    例如,LATIN SMALL LETTER E WITH ACUTE(U+00E9)就是标准相等于LATIN SMALL LETTER E(U+0065)后面加上COMBINING ACUTE ACCENT(U+0301)。这两个字符群集都是表示字符é的有效方式,所以它们被认为是标准相等的:

    // "Voulez-vous un café?" 使用 LATIN SMALL LETTER E WITH ACUTE
    let eAcuteQuestion = "Voulez-vous un caf\u{E9}?"
    
    // "Voulez-vous un café?" 使用 LATIN SMALL LETTER E and COMBINING ACUTE ACCENT
    let combinedEAcuteQuestion = "Voulez-vous un caf\u{65}\u{301}?"
    
    if eAcuteQuestion == combinedEAcuteQuestion {
        print("These two strings are considered equal")
    }
    // 打印输出 "These two strings are considered equal"
    

    相反,英语中的LATIN CAPITAL LETTER A(U+0041,或者A)不等于俄语中的CYRILLIC CAPITAL LETTER A(U+0410,或者A)。两个字符看着是一样的,但却有不同的语言意义:

    let latinCapitalLetterA: Character = "\u{41}"
    
    let cyrillicCapitalLetterA: Character = "\u{0410}"
    
    if latinCapitalLetterA != cyrillicCapitalLetterA {
        print("These two characters are not equivalent")
    }
    // 打印 "These two characters are not equivalent"
    

    注意:
    在 Swift 中,字符串和字符并不区分地域(not locale-sensitive)。

    前缀/后缀相等

    通过调用字符串的hasPrefix(_:)/hasSuffix(_:)方法来检查字符串是否拥有特定前缀/后缀,两个方法均接收一个String类型的参数,并返回一个布尔值。

    下面的例子以一个字符串数组表示莎士比亚话剧《罗密欧与朱丽叶》中前两场的场景位置:

    let romeoAndJuliet = [
        "Act 1 Scene 1: Verona, A public place",
        "Act 1 Scene 2: Capulet's mansion",
        "Act 1 Scene 3: A room in Capulet's mansion",
        "Act 1 Scene 4: A street outside Capulet's mansion",
        "Act 1 Scene 5: The Great Hall in Capulet's mansion",
        "Act 2 Scene 1: Outside Capulet's mansion",
        "Act 2 Scene 2: Capulet's orchard",
        "Act 2 Scene 3: Outside Friar Lawrence's cell",
        "Act 2 Scene 4: A street in Verona",
        "Act 2 Scene 5: Capulet's mansion",
        "Act 2 Scene 6: Friar Lawrence's cell"
    ]
    

    您可以调用hasPrefix(_:)方法来计算话剧中第一幕的场景数:

    var act1SceneCount = 0
    for scene in romeoAndJuliet {
        if scene.hasPrefix("Act 1 ") {
            act1SceneCount += 1
        }
    }
    print("There are \(act1SceneCount) scenes in Act 1")
    // 打印输出 "There are 5 scenes in Act 1"
    

    相似地,您可以用hasSuffix(_:)方法来计算发生在不同地方的场景数:

    var mansionCount = 0
    var cellCount = 0
    for scene in romeoAndJuliet {
        if scene.hasSuffix("Capulet's mansion") {
            mansionCount += 1
        } else if scene.hasSuffix("Friar Lawrence's cell") {
            cellCount += 1
        }
    }
    print("\(mansionCount) mansion scenes; \(cellCount) cell scenes")
    // 打印输出 "6 mansion scenes; 2 cell scenes"
    

    注意:
    hasPrefix(_:)hasSuffix(_:)方法都是在每个字符串中逐字符比较其可扩展的字符群集是否标准相等,详细描述在字符串/字符相等。

    字符串的 Unicode 表示形式

    当一个 Unicode 字符串被写进文本文件或者其他储存时,字符串中的 Unicode 标量会用 Unicode 定义的几种编码格式(encoding forms)编码。每一个字符串中的小块编码都被称代码单元(code units)。这些包括 UTF-8 编码格式(编码字符串为8位的代码单元), UTF-16 编码格式(编码字符串位16位的代码单元),以及 UTF-32 编码格式(编码字符串32位的代码单元)。

    Swift 提供了几种不同的方式来访问字符串的 Unicode 表示形式。 您可以利用for-in来对字符串进行遍历,从而以 Unicode 可扩展的字符群集的方式访问每一个Character值。 该过程在 使用字符 中进行了描述。

    另外,能够以其他三种 Unicode 兼容的方式访问字符串的值:

    • UTF-8 代码单元集合 (利用字符串的utf8属性进行访问)
    • UTF-16 代码单元集合 (利用字符串的utf16属性进行访问)
    • 21位的 Unicode 标量值集合,也就是字符串的 UTF-32 编码格式 (利用字符串的unicodeScalars属性进行访问)

    下面由D,o,g,(DOUBLE EXCLAMATION MARK, Unicode 标量 U+203C)和?(DOG FACE,Unicode 标量为U+1F436)组成的字符串中的每一个字符代表着一种不同的表示:

    let dogString = "Dog‼?"
    

    UTF-8 表示

    您可以通过遍历Stringutf8属性来访问它的UTF-8表示。 其为String.UTF8View类型的属性,UTF8View是无符号8位 (UInt8) 值的集合,每一个UInt8值都是一个字符的 UTF-8 表示:

    Character D
    U+0044
    o
    U+006F
    g
    U+0067

    U+203C
    ?
    U+1F436
    UTF-8
    Code Unit
    68 111 103 226 128 188 240 159 144 182
    Position 0 1 2 3 4 5 6 7 8 9
    for codeUnit in dogString.utf8 {
        print("\(codeUnit) ", terminator: "")
    }
    print("")
    // 68 111 103 226 128 188 240 159 144 182
    

    上面的例子中,前三个10进制codeUnit值 (68111103) 代表了字符Do和 g,它们的 UTF-8 表示与 ASCII 表示相同。 接下来的三个10进制codeUnit值 (226128188) 是DOUBLE EXCLAMATION MARK的3字节 UTF-8 表示。 最后的四个codeUnit值 (240159144182) 是DOG FACE的4字节 UTF-8 表示。

    UTF-16 表示

    您可以通过遍历Stringutf16属性来访问它的UTF-16表示。 其为String.UTF16View类型的属性,UTF16View是无符号16位 (UInt16) 值的集合,每一个UInt16都是一个字符的 UTF-16 表示:

    Character D
    U+0044
    o
    U+006F
    g
    U+0067

    U+203C
    ?
    U+1F436
    UTF-16
    Code Unit
    68 111 103 8252 55357 56374
    Position 0 1 2 3 4 5
    for codeUnit in dogString.utf16 {
        print("\(codeUnit) ", terminator: "")
    }
    print("")
    // 68 111 103 8252 55357 56374
    

    同样,前三个codeUnit值 (68111103) 代表了字符Dog,它们的 UTF-16 代码单元和 UTF-8 完全相同(因为这些 Unicode 标量表示 ASCII 字符)。

    第四个codeUnit值 (8252) 是一个等于十六进制203C的的十进制值。这个代表了DOUBLE EXCLAMATION MARK字符的 Unicode 标量值U+203C。这个字符在 UTF-16 中可以用一个代码单元表示。

    第五和第六个codeUnit值 (5535756374) 是DOG FACE字符的 UTF-16 表示。 第一个值为U+D83D(十进制值为55357),第二个值为U+DC36(十进制值为56374)。

    Unicode 标量表示

    您可以通过遍历String值的unicodeScalars属性来访问它的 Unicode 标量表示。 其为UnicodeScalarView类型的属性,UnicodeScalarViewUnicodeScalar类型的值的集合。UnicodeScalar是21位的 Unicode 代码点。

    每一个UnicodeScalar拥有一个value属性,可以返回对应的21位数值,用UInt32来表示:

    Character D
    U+0044
    o
    U+006F
    g
    U+0067

    U+203C
    ?
    U+1F436
    Unicode Scalar
    Code Unit
    68 111 103 8252 128054
    Position 0 1 2 3 4
    for scalar in dogString.unicodeScalars {
        print("\(scalar.value) ", terminator: "")
    }
    print("")
    // 68 111 103 8252 128054
    

    前三个UnicodeScalar值(68111103)的value属性仍然代表字符Dog。 第四个codeUnit值(8252)仍然是一个等于十六进制203C的十进制值。这个代表了DOUBLE EXCLAMATION MARK字符的 Unicode 标量U+203C

    第五个UnicodeScalar值的value属性,128054,是一个十六进制1F436的十进制表示。其等同于DOG FACE的 Unicode 标量U+1F436

    作为查询它们的value属性的一种替代方法,每个UnicodeScalar值也可以用来构建一个新的String值,比如在字符串插值中使用:

    for scalar in dogString.unicodeScalars {
        print("\(scalar) ")
    }
    // D
    // o
    // g
    // ‼
    // ?

    如果觉得对你有帮助,可以赏赐点什么,鼓励一下!

    微信支付:   支付宝:

     

    展开全文
  • swift3.0 中字符串截取

    2016-07-31 12:29:13
    swift3.0 中不能直接使用下标数字进行字符串解决,只能使用String.Index来做位置索引,要想实现截取功能首先得获取到String.Index; 下面两段代码获取开头可结尾,获取中间部分参数用RangeIndex>即可; ...
  • swift 字符串

    2017-02-03 16:25:49
    字符串字面量 可以在代码中包含一段预定义的字符串值作为字符串字面量。字符串字面量是由双引号包裹着的具有固定顺序的文本字符集。字符串字面量可以用于为常量和变量提供初始化值:let someString = "some string" ...
  • 先介绍一下Swift String 自身的方法,后面介绍简单的使用方法 1、截取前面5个字符 let substr = string.prefix(5) 2、截取后面5个字符 let substr = string.suffix(5) 3、获取下标 N 到 M 的字符...
  • 访问首元素 访问最后一个元素 文档: The endIndex property is the position after the last character in a String.... endIndex是最后一个元素后边的那个元素,因此不能直接访问,否则会崩溃。...
  • Swift-字符和字符串

    2016-07-30 22:43:12
    对比 OC 与 Swift字符的区别 char charValue = 'a';//OC当中的字符:var charValue1:Character = "a" //swift当中的字符: Swift和OC字符不一样 1.Swift是用双引号 2.Swift中的字符类型和OC中的也不一样 OC中的...
  • [swift]4.0原生字符串

    2017-03-05 15:40:42
    swift】4.0原生字符串
  • Swift 字符串的小技巧
  • blog.csdn.net/hello_hwc之前写过一篇Swift String的基础,想了解的同学可以看下。 http://blog.csdn.net/hello_hwc/article/details/39853023替换把?替换为/var url = ...
  • /**********************字符串和字符*************************/ // 1, NSString是多个Characters 的集合 // 2, 字符串字面量(String Literals) let someString = "Some
  • Swift字符串由String类型表示。可以通过各种方式访问一个String的内容,包括作为Character值的集合。 Swift String和Character类型提供了一种快速,Unicode-compliant 的方式来处理代码中的文本。字符串创建和操作的...
  • 一:常用类型 let 声明常量 var 声明变量 2、if语句里的判断必须是逻辑的值,像表达式和bool类型(这个也是经常出错的地方) ...3、元组:将多个不同的值集合成一个数据 ...4、Optionals可选值:表示这个变量...5、字符串
  • CSDN越来越不好用了,登录要老...swift截断String 末尾字符可以这样做:var sb = Strings.empty for Id in iSelected.keys{ sb = sb + Id + "," } if(!sb.isEmpty){ return (sb as NSString).substringToIndex(count
  • iOS - Swift String 字符串

    2017-02-06 10:13:03
    前言1、字符串的输出2、字符串的创建3、字符串长度的计算4字符串位置的获取5、字符串成员的引用(取字符)6、字符串的连接7、字符串的比较8、字符串的大小写转换9、字符串与数字的相互转换10、在字符串中查找子串...
  • 字符串和字符(Strings and Characters) 1.0 翻译:wh1100717 校对:Hawstein 2.0 翻译+校对:DianQK 2.1 翻译:DianQK 校对:shanks, Realank,  2.2 校对:SketchK 3.0 校对:CMB 版本日期:2016-09-13 本...
1 2 3 4 5 ... 20
收藏数 1,862
精华内容 744