Swift Language
文字列と文字

構文

• String.characters //文字列内の文字の配列を返します
• String.characters.count //文字数を返します。
• String.utf8 // String.UTF8Viewは、文字列内のUTF-8文字ポイントを返します
• String.utf16 // String.UTF16Viewは、文字列内のUTF-16文字ポイントを返します
• String.unicodeScalars // String.UnicodeScalarViewは、文字列内のUTF-32文字ポイントを返します。
• String.isEmpty //文字列にテキストが含まれていない場合はtrueを返します。
• String.hasPrefix（String）//文字列の先頭に引数がある場合はtrueを返します。
• String.hasSuffix（String）//文字列に引数がついている場合はtrueを返します。
• String.startIndex //文字列の最初の文字に対応するインデックスを返します
• String.endIndex //文字列の最後の文字の後ろに対応するインデックスを返します
• String.components（separatedBy：String）//指定された区切り文字列で区切られた部分文字列を含む配列を返します
• String.append（Character）// Stringに引数として与えられた文字を追加します。

備考

文字列と文字リテラル

Swiftの文字列リテラルは、二重引用符（ " ）で区切られています。

let greeting = "Hello!"  // greeting's type is String

文字は限りリテラルは一書記素クラスタが含まれているとして、文字列リテラルで初期化することができます。

let chr: Character = "H" // valid
let chr2: Character = "😊" // valid
let chr3: Character = "abc" // invalid - multiple grapheme clusters

文字列の補間

文字列補間は、式を文字列リテラルに直接挿入することを可能にします。これは、文字列、整数、浮動小数点数などのすべてのタイプの値で行うことができます。

構文はバックスラッシュとそれに続く値をラップする括弧で囲まれています。 \(value) 。有効な式は、関数呼び出しを含む括弧内に現れることがあります。

let number = 5
let interpolatedNumber = "\(number)"  // string is "5"
let fortyTwo = "\(6 * 7)"             // string is "42"

let example = "This post has \(number) view\(number == 1 ? "" : "s")"
// It will output "This post has 5 views" for the above example.
// If the variable number had the value 1, it would output "This post has 1 view" instead.

カスタム型の場合 、文字列補間のデフォルトの動作は、 "\(myobj)"がprint(myobj)と同じ表現であるString(myobj)と等価であることです。自分のタイプにCustomStringConvertibleプロトコルを実装することで、この動作をカスタマイズできます。

特殊文字

文字列リテラルで使用するには、特殊なエスケープシーケンスが必要です。

例：

let message = "Then he said, \"I \u{1F496} you!\""

print(message) // Then he said, "I 💖 you!"

文字列を連結する

文字列を+演算子で連結して新しい文字列を生成する：

let name = "John"
let surname = "Appleseed"
let fullName = name + " " + surname  // fullName is "John Appleseed"

+= 複合代入演算子を使用して、またはメソッドを使用して、 可変文字列に追加します。

let str2 = "there"
var instruction = "look over"
instruction += " " + str2  // instruction is now "look over there"

var instruction = "look over"
instruction.append(" " + str2)  // instruction is now "look over there"

可変文字列に1文字追加する：

var greeting: String = "Hello"
let exclamationMark: Character = "!"
greeting.append(exclamationMark) 
// produces a modified String (greeting) = "Hello!"

変更可能な文字列に複数の文字を追加する

var alphabet:String = "my ABCs: "
alphabet.append(contentsOf: (0x61...0x7A).map(UnicodeScalar.init)
                                         .map(Character.init) )
// produces a modified string (alphabet) = "my ABCs: abcdefghijklmnopqrstuvwxyz"

joinWithSeparator(_:)を使用して一連の文字列を結合して新しい文字列をjoinWithSeparator(_:) 。

let words = ["apple", "orange", "banana"]
let str = words.joinWithSeparator(" & ")

print(str)   // "apple & orange & banana"

文字列を調べて比較する

文字列が空であるかどうかを確認する：

if str.isEmpty {
    // do something if the string is empty
}

// If the string is empty, replace it with a fallback:
let result = str.isEmpty ? "fallback string" : str

2つの文字列が等しいかどうかをチェックします（ Unicode標準的な意味で）。

"abc" == "def"          // false
"abc" == "ABC"          // false
"abc" == "abc"          // true

// "LATIN SMALL LETTER A WITH ACUTE" == "LATIN SMALL LETTER A" + "COMBINING ACUTE ACCENT"
"\u{e1}" == "a\u{301}"  // true

文字列が別の文字列で始まり/終わるかどうかをチェックする：

"fortitude".hasPrefix("fort")      // true
"Swift Language".hasSuffix("age")  // true

文字列のエンコーディングと分解

Swift Stringは、 Unicodeコードポイントで構成されています。それは分解され、いくつかの異なる方法でコード化することができます。

let str = "ที่👌①!"

ストリングの分解

文字列のcharactersはUnicode 拡張書記素クラスタです。

Array(str.characters)  // ["ที่", "👌", "①", "!"]

unicodeScalarsは文字列を構成するUnicode コードポイントです（ ที่は1つの書記素クラスタですが、3つのコードポイント - 3607,3637,3656 - 結果の配列の長さはcharactersと同じではありません）。

str.unicodeScalars.map{ $0.value }  // [3607, 3637, 3656, 128076, 9312, 33]

文字列をUTF-8 （ UInt8のシーケンス）またはUTF-16 （ UInt16のシーケンス）としてエンコードおよび分解できます。

Array(str.utf8)   // [224, 184, 151, 224, 184, 181, 224, 185, 136, 240, 159, 145, 140, 226, 145, 160, 33]
Array(str.utf16)  // [3607, 3637, 3656, 55357, 56396, 9312, 33]

文字列の長さと反復

文字列のcharacters 、 unicodeScalars 、 utf8 、およびutf16はすべてCollectionであるため、 countを取得してそれらを繰り返し処理できます。

// NOTE: These operations are NOT necessarily fast/cheap! 

str.characters.count     // 4
str.unicodeScalars.count // 6
str.utf8.count           // 17
str.utf16.count          // 7

for c in str.characters { // ...
for u in str.unicodeScalars { // ...
for byte in str.utf8 { // ...
for byte in str.utf16 { // ...

Unicode

設定値

Unicodeを直接使用する

var str: String = "I want to visit 北京, Москва, मुंबई, القاهرة, and 서울시. 😊"
var character: Character = "🌍"

16進値の使用

var str: String = "\u{61}\u{5927}\u{1F34E}\u{3C0}" // a大🍎π
var character: Character = "\u{65}\u{301}" // é = "e" + accent mark

スウィフトCharacterは複数のUnicodeコードポイントで構成できますが、1文字に見えることに注意してください。これは、Extended Grapheme Clusterと呼ばれます。

コンバージョン

文字列 - > 16進数

// Accesses views of different Unicode encodings of `str`
str.utf8
str.utf16
str.unicodeScalars // UTF-32

Hex - > String

let value0: UInt8 = 0x61
let value1: UInt16 = 0x5927
let value2: UInt32 = 0x1F34E

let string0 = String(UnicodeScalar(value0)) // a
let string1 = String(UnicodeScalar(value1)) // 大
let string2 = String(UnicodeScalar(value2)) // 🍎

// convert hex array to String
let myHexArray = [0x43, 0x61, 0x74, 0x203C, 0x1F431] // an Int array
var myString = ""
for hexValue in myHexArray {
    myString.append(UnicodeScalar(hexValue))
}
print(myString) // Cat‼🐱

UTF-8とUTF-16では、絵文字のようなものを1つのUTF-16値でエンコードすることができないため、変換は必ずしも簡単ではありません。サロゲートペアが必要です。

文字列の反転

let aString = "This is a test string."

// first, reverse the String's characters 
let reversedCharacters = aString.characters.reverse()

// then convert back to a String with the String() initializer
let reversedString = String(reversedCharacters)

print(reversedString) // ".gnirts tset a si sihT"

let reversedCharacters = aString.characters.reversed()
let reversedString = String(reversedCharacters)

大文字と小文字の文字列

Stringのすべての文字を大文字または小文字にするには：

let text = "AaBbCc"
let uppercase = text.uppercaseString // "AABBCC"
let lowercase = text.lowercaseString // "aabbcc"

let text = "AaBbCc"
let uppercase = text.uppercased() // "AABBCC"
let lowercase = text.lowercased() // "aabbcc"

文字列に定義されたセットの文字が含まれているかどうかを確認する

手紙

let letters = CharacterSet.letters

let phrase = "Test case"
let range = phrase.rangeOfCharacter(from: letters)

// range will be nil if no letters is found
if let test = range {
   print("letters found")
}
else {
   print("letters not found")
}

let letters = NSCharacterSet.letterCharacterSet()

let phrase = "Test case"
let range = phrase.rangeOfCharacterFromSet(letters)

// range will be nil if no letters is found
if let test = range {
   print("letters found")
}
else {
  print("letters not found")
}

Objective-C NSCharacterSetクラスにもブリッジされている新しいCharacterSet構造体は、いくつかの事前定義セットを次のように定義します。

• decimalDigits
• capitalizedLetters
• alphanumerics
• controlCharacters
• illegalCharacters
• NSCharacterSetリファレンスでもっと詳しく調べることができます。

独自の文字セットを定義することもできます。

let phrase = "Test case"
let charset = CharacterSet(charactersIn: "t")

if let _ = phrase.rangeOfCharacter(from: charset, options: .caseInsensitive) {
   print("yes") 
}
else {
   print("no")
}

let charset = NSCharacterSet(charactersInString: "t")

if let _ = phrase.rangeOfCharacterFromSet(charset, options: .CaseInsensitiveSearch, range: nil) {
   print("yes")
}
else {
    print("no")
}

範囲を含めることもできます：

let phrase = "Test case"
let charset = CharacterSet(charactersIn: "t")

if let _ = phrase.rangeOfCharacter(from: charset, options: .caseInsensitive, range: phrase.startIndex..<phrase.endIndex)) {
   print("yes") 
}
else {
   print("no")
}

文字の出現を文字列にカウントする

与えられたStringとCharacter

let text = "Hello World"
let char: Character = "o"

CharacterがString現れる回数を数えます。

let sensitiveCount = text.characters.filter { $0 == char }.count // case-sensitive
let insensitiveCount = text.lowercaseString.characters.filter { $0 == Character(String(char).lowercaseString) } // case-insensitive

セットに定義されていない文字列から文字を削除する

func removeCharactersNotInSetFromText(text: String, set: Set<Character>) -> String {
   return String(text.characters.filter { set.contains( $0) })
}

let text = "Swift 3.0 Come Out"
var chars = Set([Character]("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLKMNOPQRSTUVWXYZ".characters))
let newText = removeCharactersNotInSetFromText(text, set: chars) // "SwiftComeOut"

func removeCharactersNotInSetFromText(text: String, set: Set<Character>) -> String {
  return String(text.characters.filter { set.contains( $0) })
}

let text = "Swift 3.0 Come Out"
var chars = Set([Character]("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLKMNOPQRSTUVWXYZ".characters))
let newText = removeCharactersNotInSetFromText(text: text, set: chars)

ストリングのフォーマット

先導するゼロ

let number: Int = 7
let str1 = String(format: "%03d", number) // 007
let str2 = String(format: "%05d", number) // 00007

小数点以下の数値

let number: Float = 3.14159
let str1 = String(format: "%.2f", number) // 3.14
let str2 = String(format: "%.4f", number) // 3.1416 (rounded)

10進数から16進数へ

let number: Int = 13627
let str1 = String(format: "%2X", number) // 353B
let str2 = String(format: "%2x", number) // 353b (notice the lowercase b)

あるいは、同じことをする専用の初期化子を使用することもできます。

let number: Int = 13627
let str1 = String(number, radix: 16, uppercase: true) //353B
let str2 = String(number, radix: 16) // 353b

任意の基数を持つ数値への小数

let number: Int = 13627
let str1 = String(number, radix: 36) // aij

基数は[2, 36] Int [2, 36] Intである。

スウィフト文字列を数値型に変換する

Int("123") // Returns 123 of Int type
Int("abcd") // Returns nil
Int("10") // Returns 10 of Int type
Int("10", radix: 2) // Returns 2 of Int type
Double("1.5") // Returns 1.5 of Double type
Double("abcd") // Returns nil

これを行うと、 Optional値が返されることに注意してください。これは、使用する前にアンラップする必要があります。

ストリング反復

let string = "My fantastic string"
var index = string.startIndex

while index != string.endIndex {
    print(string[index])
    index = index.successor()
}

let string = "My fantastic string"
var currentIndex = string.startIndex

while currentIndex != string.endIndex {
    print(string[currentIndex])
    currentIndex = string.index(after: currentIndex)
}

そして、例えば、あなたが他の方法をしたい場合：

var index:String.Index? = string.endIndex.predecessor()

while index != nil {
    print(string[index!])
    if index != string.startIndex {
        index = index.predecessor()
    }
    else {
        index = nil
    }
}

var currentIndex: String.Index? = string.index(before: string.endIndex)

while currentIndex != nil {
    print(string[currentIndex!])
    if currentIndex != string.startIndex {
        currentIndex = string.index(before: currentIndex!)
    }
    else {
        currentIndex = nil
    }
}

Indexはオブジェクト型であり、 Intではありません。次のように文字列の文字にアクセスすることはできません：

let string = "My string"
string[2] // can't do this
string.characters[2] // and also can't do this

ただし、次のように特定のインデックスを取得できます。

index = string.startIndex.advanceBy(2)

currentIndex = string.index(string.startIndex, offsetBy: 2)

そして、このように後ろに行くことができます：

index = string.endIndex.advancedBy(-2)

currentIndex = string.index(string.endIndex, offsetBy: -2)

文字列の境界を超えている場合、または制限を指定する場合は、次のように使用できます。

index = string.startIndex.advanceBy(20, limit: string.endIndex)

currentIndex = string.index(string.startIndex, offsetBy: 20, limitedBy: string.endIndex)

代わりに、文字列内の文字を繰り返し処理することもできますが、これはコンテキストによってはあまり役に立ちません。

for c in string.characters {
    print(c)
}

先頭と末尾のWhiteSpaceとNewLineを削除する

let someString = "  Swift Language  \n"
let trimmedString = someString.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceAndNewlineCharacterSet())
// "Swift Language"

let trimmedWhiteSpace = someString.stringByTrimmingCharactersInSet(NSCharacterSet.whitespaceCharacterSet())
// "Swift Language  \n"

let trimmedNewLine = someString.stringByTrimmingCharactersInSet(NSCharacterSet.newlineCharacterSet())
// "  Swift Language  "

let someString = "  Swift Language  \n"

let trimmedString = someString.trimmingCharacters(in: .whitespacesAndNewlines)
// "Swift Language"

let trimmedWhiteSpace = someString.trimmingCharacters(in: .whitespaces)
// "Swift Language  \n"

let trimmedNewLine = someString.trimmingCharacters(in: .newlines)
// "  Swift Language  "

注：これらのメソッドはすべてFoundation属します。使用import Foundation財団は、すでにココアやUIKitのような他のライブラリを経由して輸入されていない場合。

データ/ NSDataとの間で文字列を変換する

StringとData / NSDataを変換するには、この文字列を特定のエンコーディングでエンコードする必要があります。最も有名なものは、Unicode文字の8ビット表現であるUTF-8であり、ASCIIベースのシステムによる送信または格納に適している。利用可能なすべてのString Encodingsリスト

Data / NSDataへのString

let data = string.data(using: .utf8)

let data = string.dataUsingEncoding(NSUTF8StringEncoding)

Data / StringへのNSData

let string = String(data: data, encoding: .utf8)

let string = String(data: data, encoding: NSUTF8StringEncoding)

文字列を配列に分割する

Swiftでは、特定の文字でスライスすることで、Stringを配列に簡単に分離できます。

let startDate = "23:51"

let startDateAsArray = startDate.components(separatedBy: ":") // ["23", "51"]`

let startDate = "23:51"

let startArray = startDate.componentsSeparatedByString(":") // ["23", "51"]`

またはセパレータが存在しない場合：

let myText = "MyText"

let myTextArray = myText.components(separatedBy: " ") // myTextArray is ["MyText"]

let myText = "MyText"

let myTextArray = myText.componentsSeparatedByString(" ") // myTextArray is ["MyText"]