一、字符串（ String  ）和字符类型（Character）

       字符串是一种字符的带次序的收集类型（相当于数组），字符是字符串中的元素。

       在Swift 语言中，字符串是编码独立的Unicode字符的组合，并提供相应方法来获取以各种Unicode呈现方式包含的字符。

       1、 字符串定义和初始化

       Swift 语言使用var或let关键字来定义一个常量字符串（不可修改）或变量字符串（可以修改）。  而不是像Object C语言一样定义两种不同的类型。

       Swift 语言允许使用一个双引号的字符串来初始化一个字符串常量或变量，如：

     let someString ="Some string literal value”

     根据以上语句，Swift推断someString常量的类型为字符串类型。

     使用如下形式创建一个单独的字符常量或变量：

   let yenSign:Character =“￥” //创建了一个初始值为’￥’的字符常量yenSign。

    可以在双引号的字符串中使用如下形式包含特殊形式的字符：

         1）\0,\\,\t,\n,\r,\" ，\’；

    2）单字节Unicode标量，写作 \xnn， nn是两个十六进制数值；

    3）双字节Unicode标量，写作\unnnn ， nnnn是四个十六进制数值；

     4）四字节Unicode标量，写作\Unnnnnnnn ， nnnnnnnn是八个十六进制数值；

     如下所示：

let wiseWords ="\"Imagination is more important than knowledge\" - Einstein"

// "Imagination is more important than knowledge" - Einstein

let dollarSign ="\x24"       //  Unicode scalar U+0024

let blackHeart ="\u2665"     // Unicode scalar U+2665

let sparklingHeart ="\U0001F496" // Unicode scalar U+1F496

      可以使用如下两种形式来创建一个空字符串值：

var emptyString =""              // empty string literal

var anotherEmptyString =String() //使用字符串的初始化语法来初始化一个新的字符串。

   通过调用字符串的isEmpty属性来检查一个字符串是否为空：

if emptyString.isEmpty {

   println("Nothing to see here")

}

    字符串是一种值类型，因此在使用字符串为另外的字符串赋值或者作为函数或方法的参数时，总是新复制一个字符串来赋值给另外的字符串或者传值给函数或方法，而原先的字符串值保持不变。

2、字符串运算和函数

   1）字符串加操作

      字符串之间或者字符串和字符之间可以使用加运算符直接相加：

  let string1 ="hello"

  let string2 =" there"

  let character1:Character ="!" 

  let stringPlusCharacter =string1 +character1     

       let stringPlusString =string1 +string2              

   字符串还可以使用字符串插入语法与其它常量、变量或表达式组合成新的字符串。

  let multiplier =3

    let message ="\(multiplier) times 2.5 is \(Double(multiplier) * 2.5)"

  // message is "3 times 2.5 is 7.5"

 2） 字符串计数

    可以使用countElements全局函数来引出一个字符串中包含的字符的数目。

let unusualMenagerie ="Koala , Snail , Penguin , Dromedary "

println("unusualMenagerie has\(countElements(unusualMenagerie)) characters”)

 3） 比较运算

    Swift支持三种形式的字符串比较运算：字符串相等、前缀相等、后缀相等。

    在两个字符串以相同次序包含真正一样的字符时才认为其相等。

let quotation ="We‘re a lot alike, you and I."

let sameQuotation ="We‘re a lot alike, you and I."

if quotation ==sameQuotation {

   println("These two strings are considered equal")

}

// prints "These two strings are considered equal"

        前缀等、后缀等比较运算使用字符串提供的两个方法hasPrefix及hasSuffix来检测一个字符串是否包含一个特定的字符串前缀或后缀。

        两个方法在两个字符串之间执行字符与字符的比较，如果比较相同，则返回一个true布尔值,否则为false.

4） 其它操作

   由于字符串是字符的收集类型，因此可以使用for-in循环来遍历其中的每个独立的字符：

for characterin"Dog!" {

   println(character)

}

       字符串还提供uppercaseString及lowercaseString两个函数来获取一个字符串的大小写版本。

let normal ="Could you help me, please?"

let shouty =normal.uppercaseString

// shouty is equal to "COULD YOU HELP ME, PLEASE?"

let whispered =normal.lowercaseString

// whispered is equal to "could you help me, please?”

3 、字符串的Unicode表现形式

      字符串可以以UTF-8、UTF-16 及21位格式的Unicode等三种不同格式来表现或存储。

      Swift提供相应不同的方式来存取字符串的不同的Unicode表现格式。

         使用字符串的utf8属性来获取字符串UTF-8 格式的表现。如：

 let dogString =“Dog!"

for codeUnit in dogString.utf8 {

   print("\(codeUnit) ")

}

print("\n")

使用字符串的utf16属性来存取字符串UTF-16格式的 表现。如：

for codeUnit in dogString.utf16 {

   print("\(codeUnit) ")

}

print("\n")

 使用字符串的unicodeScalars属性来存取字符串Unicode格式的表现。如：

for scalar in dogString.unicodeScalars {

   print("\(scalar.value) ")

}

print("\n")

或

for scalar in dogString.unicodeScalars {

   print("\(scalar) ")

}

   

      数组以次序存储相同类型的值，词典以键值的形式存储相同类型的值。

      2.1 、数组类型

  1） 数组的创建和初始化

      可以使用如下形式创建一个存储字符串值的数组：

      var shoppingList = ["Eggs",“Milk”]

       另外如果Swift可以从上下文中推断出类型信息 ，例如从上下文的函数参数或已经初始化的特定类型的变量或常量中推断。你也能使用［］语法来创建一个空的数组。例如：

someInts.append(3)

// someInts 现在包含一个整形的值3.

someInts = []

// someInts 现在仍是类型为Int[]的一个空数组

var anotherThreeDoubles =Array(count:3,repeatedValue:2.5)

     var sixDoubles =threeDoubles +anotherThreeDoubles

    由于上面定义的数组shoppingList被声明为一个字符串数组变量，因此可以对它修改或添加。常量类型的数组不允许修改数组的尺寸，但允许为存在的值设置新值。

     shoppingList.insert("Maple Syrup",atIndex:0)

      letapples =shoppingList.removeLast()

if shoppingList.isEmpty {
   println("The shopping list is empty.")
}else {
   println("The shopping list is not empty.")

}

    var firstItem =shoppingList[0]

    或使用subscript语法来一次改变数组中一个范围内的项的值：

         shoppingList[4...6] = ["Bananas","Apples"]

namesOfIntegers[16] = "sixteen"
// namesOfIntegers 现在包含一个项，其键等于16，对应的值为"sixteen"
namesOfIntegers = [:]
// namesOfIntegers 现在是一个类型为<Int,String>的一个空词典。

    println("The dictionary of airports contains \(airports.count) items.")

airports["LHR"] = “London"

if let airportName =airports["DUB"] {
   println("The name of the airport is \(airportName).")
}else {
   println("That airport is not in the airports dictionary.")
}

       airports["APL"] = "Apple International"
       airports["APL"] = nil

if let oldValue =airports.updateValue("Dublin International",forKey:"DUB") {
   println("The old value for DUB was \(oldValue).")
}

if let removedValue =airports.removeValueForKey("DUB") {
   println("The removed airport‘s name is \(removedValue).")
}else {
   println("The airports dictionary does not contain a value for DUB.")
}

for (airportCode,airportName) in airports {
   println("\(airportCode):\(airportName)")
}

for airportCode in airports.keys {
   println("Airport code: \(airportCode)")
}
for airportName in airports.values {
   println("Airport name: \(airportName)")
}

                                   版权所有，请转载时清楚注明链接和出处！