String

Overview 概要

A string is a series of characters, such as "Swift", that forms a collection. Strings in Swift are Unicode correct and locale insensitive, and are designed to be efficient. The String type bridges with the Objective-C class NSString and offers interoperability with C functions that works with strings. 文字列は一続きの文字です、例えば"Swift"など、それはあるコレクションを形成します。Swiftでの文字列は、ユニコードに正確でロケールに影響されず、そして効率的であるように設計されます。String型は、Objective-CクラスNSStringとブリッジします、そしてC関数で文字列を扱うものと相互運用を提示します。

You can create new strings using string literals or string interpolations. A string literal is a series of characters enclosed in quotes. あなたは新しい文字列を、文字列リテラルまたは文字列補間を使って作成できます。文字列リテラルは、引用符に囲まれた一連の文字です。

let greeting = "Welcome!"

String interpolations are string literals that evaluate any included expressions and convert the results to string form. String interpolations give you an easy way to build a string from multiple pieces. Wrap each expression in a string interpolation in parentheses, prefixed by a backslash. 文字列補間は文字列リテラルです、それは、何らかの含まれた式を評価して、その結果を文字列形式へ変換します。文字列補間は、多様な断片からある文字列を組み立てる簡単な方法をあなたに提供します。文字列補間の中の式それぞれを丸括弧で包んで、バックスラッシュを前においてください。

let name = "Rosa"
let personalizedGreeting = "Welcome, \(name)!"
// personalizedGreeting == "Welcome, Rosa!"


let price = 2
let number = 3
let cookiePrice = "\(number) cookies: $\(price * number)."
// cookiePrice == "3 cookies: $6."

Combine strings using the concatenation operator (+). 連結演算子（+）を使って文字列を結合してください。

let longerGreeting = greeting + " We're glad you're here!"
// longerGreeting == "Welcome! We're glad you're here!"

Multiline string literals are enclosed in three double quotation marks ("""), with each delimiter on its own line. Indentation is stripped from each line of a multiline string literal to match the indentation of the closing delimiter. 複数行文字列リテラルは、３つの二重引用符記号（"""）に囲まれ、各区切り子をそれの独自の行上に持ちます。字下げは、複数行文字列リテラルの各行から剥ぎ取られて、閉じ区切り子の字下げに合わせられます。

let banner = """
          __,
         (           o  /) _/_
          `.  , , , ,  //  /
        (___)(_(_/_(_ //_ (__
                     /)
                    (/
        """

Modifying and Comparing Strings 文字列の修正と比較

Strings always have value semantics. Modifying a copy of a string leaves the original unaffected. 文字列は常に値意味論を持ちます。ある文字列のコピーを修正しても、元のものはそのままで影響を受けません。

var otherGreeting = greeting
otherGreeting += " Have a nice time!"
// otherGreeting == "Welcome! Have a nice time!"


print(greeting)
// Prints "Welcome!"

Comparing strings for equality using the equal-to operator (==) or a relational operator (like < or >=) is always performed using Unicode canonical representation. As a result, different representations of a string compare as being equal. 同等演算子（==）または関係演算子（<や>=のような）を使って同等性について文字列を比較することは、常にユニコード正準表現を使って実行されます。結果として、ある文字列の異なる表現は等しいと比較されます。

let cafe1 = "Cafe\u{301}"
let cafe2 = "Café"
print(cafe1 == cafe2)
// Prints "true"

The Unicode scalar value "\u{301}" modifies the preceding character to include an accent, so "e\u{301}" has the same canonical representation as the single Unicode scalar value "é". ユニコードスカラー値"\u{301}"は、先行する文字を修飾してアクセントを含めます、それで"e\u{301}"は単一のユニコードスカラー値"é"と同じ正準表現を持ちます。

Basic string operations are not sensitive to locale settings, ensuring that string comparisons and other operations always have a single, stable result, allowing strings to be used as keys in Dictionary instances and for other purposes. 基本的な文字列演算はロケール設定に影響を受けず、文字列比較および他の演算が常にある単一の、安定した結果を持つことを保証して、文字列がDictionaryインスタンスにおけるキーとしておよび他の目的のために使われることを可能にしています。

Accessing String Elements 文字列要素にアクセスする

A string is a collection of extended grapheme clusters, which approximate human-readable characters. Many individual characters, such as “é”, “김”, and “🇮🇳”, can be made up of multiple Unicode scalar values. These scalar values are combined by Unicode’s boundary algorithms into extended grapheme clusters, represented by the Swift Character type. Each element of a string is represented by a Character instance. ある文字列は、拡張書記素クラスタのコレクションです、それらはだいたいは人間が読むことができる文字です。多くの単一の文字、例えば「é」、「김」、そして「🇮🇳」などが、複数のユニコードスカラー値から構成されます。これらのスカラー値は、ユニコード境界アルゴリズムによって拡張書記素クラスタへと、SwiftのもつCharacter型によって表されるものへと、組み合わされます。文字列の各要素は、あるCharacterインスタンスによって表現されます。

For example, to retrieve the first word of a longer string, you can search for a space and then create a substring from a prefix of the string up to that point: 例えば、ある長い文字列の最初の単語を取り出すには、あなたは空白を捜してから、その文字列の前の部分からその地点までの下位文字列を作成できます：

let name = "Marie Curie"
let firstSpace = name.firstIndex(of: " ") ?? name.endIndex
let firstName = name[..<firstSpace]
// firstName == "Marie"

The firstName constant is an instance of the Substring type—a type that represents substrings of a string while sharing the original string’s storage. Substrings present the same interface as strings. firstName定数は、Substring型 — ある文字列の下位文字列をオリジナル文字列のもつストレージを共有している間に表す型のインスタンスです。下位文字列は、文字列と同じインターフェイスを提供します。

print("\(name)'s first name has \(firstName.count) letters.")
// Prints "Marie Curie's first name has 5 letters."

Accessing a String’s Unicode Representation 文字列のユニコード表現にアクセスする

If you need to access the contents of a string as encoded in different Unicode encodings, use one of the string’s unicodeScalars, utf16, or utf8 properties. Each property provides access to a view of the string as a series of code units, each encoded in a different Unicode encoding. あなたがある文字列の内容に異なるユニコードエンコーディングでエンコードされたようにアクセスする必要があるならば、その文字列のもつunicodeScalars、utf16、またはutf8プロパティの１つを使ってください。各プロパティは、文字列のあるビューへのアクセスを一続きのコード単位として提供し、それぞれが異なるユニコードエンコーディングにおいてエンコードされます。

To demonstrate the different views available for every string, the following examples use this String instance: あらゆる文字列で利用可能な異なるビューを実際に示すために、以降の例はこのStringインスタンスを使います：

let cafe = "Cafe\u{301} du 🌍"
print(cafe)
// Prints "Café du 🌍"

The cafe string is a collection of the nine characters that are visible when the string is displayed. cafe文字列は、９つの文字からなる１つのコレクションで、その文字列が表示される時に見られます。

print(cafe.count)
// Prints "9"
print(Array(cafe))
// Prints "["C", "a", "f", "é", " ", "d", "u", " ", "🌍"]"

Unicode Scalar View ユニコードスカラービュー

A string’s unicodeScalars property is a collection of Unicode scalar values, the 21-bit codes that are the basic unit of Unicode. Each scalar value is represented by a Unicode.Scalar instance and is equivalent to a UTF-32 code unit. ある文字列のもつunicodeScalarsプロパティは、ユニコードの基本単位である21ビットコード、ユニコードスカラー値いくつかからなるコレクションです。各スカラー値は、Unicode.Scalarインスタンスによって表されて、ひとつのUTF-32コード単位と同等です。

print(cafe.unicodeScalars.count)
// Prints "10"
print(Array(cafe.unicodeScalars))
// Prints "["C", "a", "f", "e", "\u{0301}", " ", "d", "u", " ", "\u{0001F30D}"]"
print(cafe.unicodeScalars.map { $0.value })
// Prints "[67, 97, 102, 101, 769, 32, 100, 117, 32, 127757]"

The unicodeScalars view’s elements comprise each Unicode scalar value in the cafe string. In particular, because cafe was declared using the decomposed form of the "é" character, unicodeScalars contains the scalar values for both the letter "e" (101) and the accent character "´" (769). unicodeScalarsビューのもつ各要素は、cafe文字列の中の各ユニコードスカラー値からなります。とりわけ、cafeは分解形式の"é"文字を使って宣言されたことから、unicodeScalarsは字"e"（101）とアクセント文字"´"（769）両方のスカラー値を含みます。

UTF-16 View UTF-16ビュー

A string’s utf16 property is a collection of UTF-16 code units, the 16-bit encoding form of the string’s Unicode scalar values. Each code unit is stored as a UInt16 instance. ある文字列のもつutf16プロパティは、その文字列のもつユニコードスカラー値の16ビット符号化形式、UTF-16コード単位いくつかからなるコレクションです。各コード単位はUInt16インスタンスとして格納されます。

print(cafe.utf16.count)
// Prints "11"
print(Array(cafe.utf16))
// Prints "[67, 97, 102, 101, 769, 32, 100, 117, 32, 55356, 57101]"

The elements of the utf16 view are the code units for the string when encoded in UTF-16. These elements match those accessed through indexed NSString APIs. utf16ビューの要素は、UTF-16で符号化される時の文字列に対するコード単位です。それらの要素は、インデックス付きNSString APIを通してアクセスされるものと一致します。

let nscafe = cafe as NSString
print(nscafe.length)
// Prints "11"
print(nscafe.character(at: 3))
// Prints "101"

UTF-8 View UTF-8ビュー

A string’s utf8 property is a collection of UTF-8 code units, the 8-bit encoding form of the string’s Unicode scalar values. Each code unit is stored as a UInt8 instance. ある文字列のもつutf8プロパティは、その文字列のもつユニコードスカラー値の８ビット符号化形式、UTF-８コード単位いくつかからなるコレクションです。各コード単位はUInt8インスタンスとして格納されます。

print(cafe.utf8.count)
// Prints "14"
print(Array(cafe.utf8))
// Prints "[67, 97, 102, 101, 204, 129, 32, 100, 117, 32, 240, 159, 140, 141]"

The elements of the utf8 view are the code units for the string when encoded in UTF-8. This representation matches the one used when String instances are passed to C APIs. utf8ビューの要素は、UTF-8で符号化される時の文字列に対するコード単位です。この表現は、StringインスタンスがC APIに渡される時に使われるものと一致します。

let cLength = strlen(cafe)
print(cLength)
// Prints "14"

Measuring the Length of a String 文字列の長さを計測する

When you need to know the length of a string, you must first consider what you’ll use the length for. Are you measuring the number of characters that will be displayed on the screen, or are you measuring the amount of storage needed for the string in a particular encoding? A single string can have greatly differing lengths when measured by its different views. あなたがある文字列の長さを知る必要がある場合、あなたが最初に考えなければならないのは、あなたが使う長さは何に対するものかということです。あなたが画面上に表示される文字の数を数えているのか、またはあなたはある特定の符号化での文字列に必要とされるストレージの量を測っているのか？。ある単一の文字列は、それの異なるビューによって測られる時に大きく違っていることがありえます。

For example, an ASCII character like the capital letter A is represented by a single element in each of its four views. The Unicode scalar value of A is 65, which is small enough to fit in a single code unit in both UTF-16 and UTF-8. 例えば、大文字のAのようなあるひとつのASCII文字は、それの４つのビューのそれぞれにおいて単一の要素で表されます。Aのユニコードスカラー値は65です、それはUTF-16およびUTF-8両方において単一のコード単位の中にぴったり収まるにの十分に小さいです。

let capitalA = "A"
print(capitalA.count)
// Prints "1"
print(capitalA.unicodeScalars.count)
// Prints "1"
print(capitalA.utf16.count)
// Prints "1"
print(capitalA.utf8.count)
// Prints "1"

On the other hand, an emoji flag character is constructed from a pair of Unicode scalar values, like "\u{1F1F5}" and "\u{1F1F7}". Each of these scalar values, in turn, is too large to fit into a single UTF-16 or UTF-8 code unit. As a result, each view of the string "🇵🇷" reports a different length. 一方で、あるemoji国旗文字は一対のユニコードスカラー値から構築されます、"\u{1F1F5}"と"\u{1F1F7}"のように。それらスカラー値のそれぞれは、今度は、ある単一のUTF-16またはUTF-8コード単位にぴったり合うには大きすぎます。結果として、文字列"🇵🇷"の各ビューは異なる長さを報告します。

let flag = "🇵🇷"
print(flag.count)
// Prints "1"
print(flag.unicodeScalars.count)
// Prints "2"
print(flag.utf16.count)
// Prints "4"
print(flag.utf8.count)
// Prints "8"

To check whether a string is empty, use its isEmpty property instead of comparing the length of one of the views to 0. Unlike with isEmpty, calculating a view’s count property requires iterating through the elements of the string. ある文字列が空かどうか調べるには、それのisEmptyプロパティを使ってください、ビューの内の１つの長さを0と比較するのでなく。isEmptyとは違い、あるビューのcountプロパティを計算することはその文字列の要素を始めから終わりまで反復していく必要があります。

Accessing String View Elements 文字列ビュー要素にアクセスする

To find individual elements of a string, use the appropriate view for your task. For example, to retrieve the first word of a longer string, you can search the string for a space and then create a new string from a prefix of the string up to that point. ある文字列の個々の要素を手に入れるには、あなたの作業に適切なビューを使ってください。例えば、ある長い文字列の最初の単語を取り出すには、あなたはその文字列を空白について調査して、それからその文字列の前の部分からその地点までの新しい文字列を作成できます。

let name = "Marie Curie"
let firstSpace = name.firstIndex(of: " ") ?? name.endIndex
let firstName = name[..<firstSpace]
print(firstName)
// Prints "Marie"

Strings and their views share indices, so you can access the UTF-8 view of the name string using the same firstSpace index. 文字列とそれのビューはインデックスを共有します、それであなたはname文字列のUTF-8ビューにアクセスすることが同じfirstSpaceインデックスを使って可能です。

print(Array(name.utf8[..<firstSpace]))
// Prints "[77, 97, 114, 105, 101]"

Note that an index into one view may not have an exact corresponding position in another view. For example, the flag string declared above comprises a single character, but is composed of eight code units when encoded as UTF-8. The following code creates constants for the first and second positions in the flag.utf8 view. Accessing the utf8 view with these indices yields the first and second code UTF-8 units. あるビューに対するインデックスが別のビューにおいて正確に対応する位置を持たないかもしれないことに注意してください。例えば、上で宣言されるflag文字列はある単一の文字で構成されます、しかしUTF-8としてエンコードされる時は８つのコード単位から構成されます。以下のコードは、flag.utf8ビューの中の１番目と２番目の位置に対する定数それぞれを作成します。utf8ビューにそれらのインデックスでアクセスすることは、１番目と２番目のUTF-8コード単位を生成します。

let firstCodeUnit = flag.startIndex
let secondCodeUnit = flag.utf8.index(after: firstCodeUnit)
// flag.utf8[firstCodeUnit] == 240
// flag.utf8[secondCodeUnit] == 159

When used to access the elements of the flag string itself, however, the secondCodeUnit index does not correspond to the position of a specific character. Instead of only accessing the specific UTF-8 code unit, that index is treated as the position of the character at the index’s encoded offset. In the case of secondCodeUnit, that character is still the flag itself. flag文字列それ自身の要素へのアクセスに使われる場合は、しかしながら、secondCodeUnitインデックスは特定の文字の位置に該当しません。特定のUTF-8コード単位にアクセスすることだけではなく、そのインデックスは、インデックスの持つエンコードされたオフセットでの文字の位置として扱われます。secondCodeUnitの場合では、その文字は依然として旗それ自体です。

// flag[firstCodeUnit] == "🇵🇷"
// flag[secondCodeUnit] == "🇵🇷"

If you need to validate that an index from one string’s view corresponds with an exact position in another view, use the index’s samePosition(in:) method or the init(_:within:) initializer. あなたがある文字列の持つビューからのインデックスが別のビューでの正確な位置と対応することを有効にする必要があるならば、そのインデックスのsamePosition(in:)メソッドまたはinit(_:within:)イニシャライザを使ってください。

if let exactIndex = secondCodeUnit.samePosition(in: flag) {
    print(flag[exactIndex])
} else {
    print("No exact match for this position.")
}
// Prints "No exact match for this position."

Performance Optimizations 性能最適化

Although strings in Swift have value semantics, strings use a copy-on-write strategy to store their data in a buffer. This buffer can then be shared by different copies of a string. A string’s data is only copied lazily, upon mutation, when more than one string instance is using the same buffer. Therefore, the first in any sequence of mutating operations may cost O(n) time and space. Swiftにおける文字列は値意味論を持ちますが、文字列はコピーオンライト戦略を使ってそれらのデータをバッファに格納します。このバッファは、それからある文字列の異なるコピーによって共有されることができます。１つ以上の文字列インスタンスが同じバッファを使っている時、変化において、ある文字列の持つデータは遅延にのみコピーされます。それゆえに、何らかの一連の変化を伴う演算において最初に、O(n)時間と空間を要するでしょう。

When a string’s contiguous storage fills up, a new buffer must be allocated and data must be moved to the new storage. String buffers use an exponential growth strategy that makes appending to a string a constant time operation when averaged over many append operations. ある文字列の隣接ストレージがいっぱいになるとき、新しいストレージが割り当てられる必要があり、データは新しいストレージに移動される必要があります。文字列バッファは指数成長戦略を使います、それはある文字列へ追加することを、多くの追加演算を平均した時に定数時間演算にします。

Bridging Between String and NSString StringとNSStringの間のブリッジ

Any String instance can be bridged to NSString using the type-cast operator (as), and any String instance that originates in Objective-C may use an NSString instance as its storage. Because any arbitrary subclass of NSString can become a String instance, there are no guarantees about representation or efficiency when a String instance is backed by NSString storage. Because NSString is immutable, it is just as though the storage was shared by a copy. The first in any sequence of mutating operations causes elements to be copied into unique, contiguous storage which may cost O(n) time and space, where n is the length of the string’s encoded representation (or more, if the underlying NSString has unusual performance characteristics). 何らかのStringインスタンスは、NSStringへブリッジされることが型キャスト演算子（as）を使って行えます、そして何らかのStringインスタンスでObjective-C起源のものはNSStringインスタンスをそれのストレージとして使っても構いません。NSStringの随意のサブクラスは何であれStringインスタンスになれるので、StringインスタンスがNSStringストレージによって裏打ちされる場合、表現または効率についての保証はありません。NSStringは不変であることから、まるでまさにストレージがコピーによって共有されたかのようです。何らかの変更を行う一連の演算の中の最初のものは、要素が固有の、隣接するストレージへとコピーされる原因となり、それはO(n)の時間と空間がかかります、そこにおいてnは文字列表現の長さです（またはそれ以上のもの、基盤となるNSStringが通常でない性能特質を持つならば）。

For more information about the Unicode terms used in this discussion, see the Unicode.org glossary. In particular, this discussion mentions extended grapheme clusters, Unicode scalar values, and canonical equivalence. この解説において使われるユニコード用語についてのさらなる情報は、Unicode.org用語集を見てください。とりわけ、この解説は拡張書記素クラスタ、ユニコードスカラー値、そして正準等価について言及します。