Tìm chỉ mục của ký tự trong Swift String


203

Đã đến lúc thừa nhận thất bại ...

Trong Objective-C, tôi có thể sử dụng một cái gì đó như:

NSString* str = @"abcdefghi";
[str rangeOfString:@"c"].location; // 2

Trong Swift, tôi thấy một cái gì đó tương tự:

var str = "abcdefghi"
str.rangeOfString("c").startIndex

... nhưng điều đó chỉ mang lại cho tôi một String.Indexcái mà tôi có thể sử dụng để đăng ký lại vào chuỗi gốc, nhưng không trích xuất một vị trí từ đó.

FWIW, rằng String.Indexcó một Ivar tin gọi là _positioncó giá trị đúng trong đó. Tôi chỉ không thấy nó lộ ra như thế nào.

Tôi biết tôi có thể dễ dàng thêm nó vào String. Tôi tò mò hơn về những gì tôi thiếu trong API mới này.


Đây là một dự án GitHub chứa nhiều phương thức mở rộng để thao tác chuỗi Swift: github.com/iamjono/SwiftString
RenniePet

Cách triển khai tốt nhất mà tôi đã tìm thấy là ở đây: stackoverflow.com/a/32306142/4550651
Carlos García

Bạn có cần phân biệt giữa Bộ giải mã Unicode và Cụm đồ thị mở rộng không?
Ben Leggiero

Câu trả lời:


248

Bạn không phải là người duy nhất không thể tìm ra giải pháp.

Stringkhông thực hiện RandomAccessIndexType. Có lẽ bởi vì chúng cho phép các ký tự có độ dài byte khác nhau. Đó là lý do tại sao chúng ta phải sử dụng string.characters.count( counthoặc countElementstrong Swift 1.x) để có được số lượng ký tự. Điều đó cũng áp dụng cho các vị trí. Đây _positioncó lẽ là một chỉ mục vào mảng byte thô và họ không muốn phơi bày điều đó. Điều String.Indexnày có nghĩa là để bảo vệ chúng ta khỏi việc truy cập byte ở giữa các ký tự.

Điều đó có nghĩa là bất kỳ chỉ mục nào bạn nhận được phải được tạo từ String.startIndexhoặc String.endIndex( String.Indexthực hiện BidirectionalIndexType). Bất kỳ chỉ số khác có thể được tạo bằng cách sử dụng successorhoặc predecessorphương pháp.

Bây giờ để giúp chúng tôi với các chỉ mục, có một bộ phương thức (các hàm trong Swift 1.x):

Swift 4.x

let text = "abc"
let index2 = text.index(text.startIndex, offsetBy: 2) //will call succ 2 times
let lastChar: Character = text[index2] //now we can index!

let characterIndex2 = text.index(text.startIndex, offsetBy: 2)
let lastChar2 = text[characterIndex2] //will do the same as above

let range: Range<String.Index> = text.range(of: "b")!
let index: Int = text.distance(from: text.startIndex, to: range.lowerBound)

Swift 3.0

let text = "abc"
let index2 = text.index(text.startIndex, offsetBy: 2) //will call succ 2 times
let lastChar: Character = text[index2] //now we can index!

let characterIndex2 = text.characters.index(text.characters.startIndex, offsetBy: 2)
let lastChar2 = text.characters[characterIndex2] //will do the same as above

let range: Range<String.Index> = text.range(of: "b")!
let index: Int = text.distance(from: text.startIndex, to: range.lowerBound)

Swift 2.x

let text = "abc"
let index2 = text.startIndex.advancedBy(2) //will call succ 2 times
let lastChar: Character = text[index2] //now we can index!
let lastChar2 = text.characters[index2] //will do the same as above

let range: Range<String.Index> = text.rangeOfString("b")!
let index: Int = text.startIndex.distanceTo(range.startIndex) //will call successor/predecessor several times until the indices match

Swift 1.x

let text = "abc"
let index2 = advance(text.startIndex, 2) //will call succ 2 times
let lastChar: Character = text[index2] //now we can index!

let range = text.rangeOfString("b")
let index: Int = distance(text.startIndex, range.startIndex) //will call succ/pred several times

Làm việc với String.Indexrất cồng kềnh nhưng sử dụng trình bao bọc để lập chỉ mục theo số nguyên (xem https://stackoverflow.com/a/25152652/669586 ) là nguy hiểm vì nó che giấu sự không hiệu quả của việc lập chỉ mục thực.

Lưu ý rằng việc triển khai lập chỉ mục Swift có vấn đề là các chỉ số / phạm vi được tạo cho một chuỗi không thể được sử dụng một cách đáng tin cậy cho một chuỗi khác , ví dụ:

Swift 2.x

let text: String = "abc"
let text2: String = "🎾🏇🏈"

let range = text.rangeOfString("b")!

//can randomly return a bad substring or throw an exception
let substring: String = text2[range]

//the correct solution
let intIndex: Int = text.startIndex.distanceTo(range.startIndex)
let startIndex2 = text2.startIndex.advancedBy(intIndex)
let range2 = startIndex2...startIndex2

let substring: String = text2[range2]

Swift 1.x

let text: String = "abc"
let text2: String = "🎾🏇🏈"

let range = text.rangeOfString("b")

//can randomly return nil or a bad substring 
let substring: String = text2[range] 

//the correct solution
let intIndex: Int = distance(text.startIndex, range.startIndex)    
let startIndex2 = advance(text2.startIndex, intIndex)
let range2 = startIndex2...startIndex2

let substring: String = text2[range2]  

1
Lúng túng nghĩ rằng nó có thể, đây dường như là câu trả lời. Hy vọng rằng hai hàm phạm vi này sẽ đưa nó vào tài liệu một thời gian trước khi phát hành cuối cùng.
Matt Wishing

Loại nào rangetrongvar range = text.rangeOfString("b")
zaph

5
@Zaph Mỗi Collectioncó một typealias IndexType. Đối với mảng, nó được định nghĩa là Int, vì Stringnó được định nghĩa là String.Index. Cả mảng và chuỗi cũng có thể sử dụng phạm vi (để tạo các chuỗi con và chuỗi con). Phạm vi là một loại đặc biệt Range<T>. Đối với chuỗi, nó Range<String.Index>, cho mảng Range<Int>.
Sulthan

1
Trong Swift 2.0, distance(text.startIndex, range.startIndex)trở thànhtext.startIndex.distanceTo(range.startIndex)
superarts.org

1
@devios String, chính xác như NSStringtrong Foundation có một phương thức gọi là hasPrefix(_:).
Sulthan

86

Swift 3.0 làm cho điều này dài dòng hơn một chút:

let string = "Hello.World"
let needle: Character = "."
if let idx = string.characters.index(of: needle) {
    let pos = string.characters.distance(from: string.startIndex, to: idx)
    print("Found \(needle) at position \(pos)")
}
else {
    print("Not found")
}

Sự mở rộng:

extension String {
    public func index(of char: Character) -> Int? {
        if let idx = characters.index(of: char) {
            return characters.distance(from: startIndex, to: idx)
        }
        return nil
    }
}

Trong Swift 2.0, điều này đã trở nên dễ dàng hơn:

let string = "Hello.World"
let needle: Character = "."
if let idx = string.characters.indexOf(needle) {
    let pos = string.startIndex.distanceTo(idx)
    print("Found \(needle) at position \(pos)")
}
else {
    print("Not found")
}

Sự mở rộng:

extension String {
    public func indexOfCharacter(char: Character) -> Int? {
        if let idx = self.characters.indexOf(char) {
            return self.startIndex.distanceTo(idx)
        }
        return nil
    }
}

Triển khai Swift 1.x:

Đối với một giải pháp Swift thuần túy, người ta có thể sử dụng:

let string = "Hello.World"
let needle: Character = "."
if let idx = find(string, needle) {
    let pos = distance(string.startIndex, idx)
    println("Found \(needle) at position \(pos)")
}
else {
    println("Not found")
}

Là một phần mở rộng cho String:

extension String {
    public func indexOfCharacter(char: Character) -> Int? {
        if let idx = find(self, char) {
            return distance(self.startIndex, idx)
        }
        return nil
    }
}

1
nhân vật bị phản đối !!
Shivam Pokhriyal

23
extension String {

    // MARK: - sub String
    func substringToIndex(index:Int) -> String {
        return self.substringToIndex(advance(self.startIndex, index))
    }
    func substringFromIndex(index:Int) -> String {
        return self.substringFromIndex(advance(self.startIndex, index))
    }
    func substringWithRange(range:Range<Int>) -> String {
        let start = advance(self.startIndex, range.startIndex)
        let end = advance(self.startIndex, range.endIndex)
        return self.substringWithRange(start..<end)
    }

    subscript(index:Int) -> Character{
        return self[advance(self.startIndex, index)]
    }
    subscript(range:Range<Int>) -> String {
        let start = advance(self.startIndex, range.startIndex)
            let end = advance(self.startIndex, range.endIndex)
            return self[start..<end]
    }


    // MARK: - replace
    func replaceCharactersInRange(range:Range<Int>, withString: String!) -> String {
        var result:NSMutableString = NSMutableString(string: self)
        result.replaceCharactersInRange(NSRange(range), withString: withString)
        return result
    }
}

7
Nghĩ về việc làm này, nhưng tôi nghĩ đó là một vấn đề mà nó che giấu ngữ nghĩa của truy cập chuỗi. Hãy tưởng tượng việc tạo một API để truy cập các danh sách được liên kết trông giống như API cho một mảng. Mọi người muốn viết mã không hiệu quả khủng khiếp.
Erik Engheim

16

Tôi đã tìm thấy giải pháp này cho swift2:

var str = "abcdefghi"
let indexForCharacterInString = str.characters.indexOf("c") //returns 2

chỉ số sẽ là gì khi str = "abcdefgchi"
Vatsal Shukla

10

Swift 5.0

public extension String {  
  func indexInt(of char: Character) -> Int? {
    return firstIndex(of: char)?.utf16Offset(in: self)
  }
}

Swift 4.0

public extension String {  
  func indexInt(of char: Character) -> Int? {
    return index(of: char)?.encodedOffset        
  }
}

chỉ mục trả về (của: phần tử) .map {target.distance (từ:
start Index

8

Tôi không chắc chắn làm thế nào để trích xuất vị trí từ String.Index, nhưng nếu bạn sẵn sàng quay lại một số khung công tác Objective-C, bạn có thể kết nối với object-c và thực hiện theo cách bạn đã từng sử dụng.

"abcdefghi".bridgeToObjectiveC().rangeOfString("c").location

Có vẻ như một số phương thức NSString chưa được (hoặc có thể sẽ không được) chuyển sang Chuỗi. Chứa cũng đến với tâm trí.


Thực tế có vẻ như việc truy cập thuộc tính vị trí của giá trị trả về là đủ để trình biên dịch suy ra loại NSString, vì vậy bridgeToObjectiveC()cuộc gọi không cần thiết. Vấn đề của tôi dường như chỉ xuất hiện khi gọi rangeOfStringtrên Chuỗi Swift hiện có trước đó. Có vẻ như là một vấn đề API ...
Matt Wishing

Nó thật thú vị. Tôi không biết nó đã được suy luận trong những trường hợp đó. Chà, khi nó đã là một Chuỗi, bạn luôn có thể sử dụng cây cầu.
Connor

8

Dưới đây là phần mở rộng Chuỗi sạch để trả lời câu hỏi:

Swift 3:

extension String {
    var length:Int {
        return self.characters.count
    }

    func indexOf(target: String) -> Int? {

        let range = (self as NSString).range(of: target)

        guard range.toRange() != nil else {
            return nil
        }

        return range.location

    }
    func lastIndexOf(target: String) -> Int? {



        let range = (self as NSString).range(of: target, options: NSString.CompareOptions.backwards)

        guard range.toRange() != nil else {
            return nil
        }

        return self.length - range.location - 1

    }
    func contains(s: String) -> Bool {
        return (self.range(of: s) != nil) ? true : false
    }
}

Swift 2.2:

extension String {    
    var length:Int {
        return self.characters.count
    }

    func indexOf(target: String) -> Int? {

        let range = (self as NSString).rangeOfString(target)

        guard range.toRange() != nil else {
            return nil
        }

        return range.location

    }
    func lastIndexOf(target: String) -> Int? {



        let range = (self as NSString).rangeOfString(target, options: NSStringCompareOptions.BackwardsSearch)

        guard range.toRange() != nil else {
            return nil
        }

        return self.length - range.location - 1

    }
    func contains(s: String) -> Bool {
        return (self.rangeOfString(s) != nil) ? true : false
    }
}

7

Bạn cũng có thể tìm thấy các chỉ mục của một ký tự trong một chuỗi như thế này,

extension String {

  func indexes(of character: String) -> [Int] {

    precondition(character.count == 1, "Must be single character")

    return self.enumerated().reduce([]) { partial, element  in
      if String(element.element) == character {
        return partial + [element.offset]
      }
      return partial
    }
  }

}

Cung cấp kết quả trong [String.Distance] tức là. [Int], như

"apple".indexes(of: "p") // [1, 2]
"element".indexes(of: "e") // [0, 2, 4]
"swift".indexes(of: "j") // []

5

Nếu bạn muốn sử dụng NSString quen thuộc, bạn có thể khai báo rõ ràng:

var someString: NSString = "abcdefghi"

var someRange: NSRange = someString.rangeOfString("c")

Tôi không chắc chắn làm thế nào để làm điều này trong Swift.


1
Điều này chắc chắn hoạt động, và có vẻ như trình biên dịch khá tích cực trong việc suy ra các loại NSString cho bạn. Tôi đã thực sự hy vọng cho một cách Swift thuần túy để làm điều này, vì nó có vẻ như là một trường hợp sử dụng đủ phổ biến.
Matt Wishing

Phải, tôi đang nhìn xung quanh, nhưng tôi không thấy điều đó. Có thể họ tập trung vào các khu vực không được ObjC hỗ trợ vì họ có thể điền vào những khoảng trống này với quá nhiều khả năng bị mất. Chỉ cần suy nghĩ thành tiếng :)
Logan

4

Nếu bạn muốn biết vị trí của một ký tự trong chuỗi dưới dạng giá trị int, hãy sử dụng:

let loc = newString.range(of: ".").location

Swift 5 : value of type 'Range<String.Index>?' has no member 'location'.
Cháu

3

Tôi biết điều này đã cũ và một câu trả lời đã được chấp nhận, nhưng bạn có thể tìm thấy chỉ mục của chuỗi trong một vài dòng mã bằng cách sử dụng:

var str : String = "abcdefghi"
let characterToFind: Character = "c"
let characterIndex = find(str, characterToFind)  //returns 2

Một số thông tin tuyệt vời khác về chuỗi Swift tại đây Chuỗi trong Swift


findkhông khả dụng trong Swift 3
AamirR

2

Điều này làm việc cho tôi,

var loc = "abcdefghi".rangeOfString("c").location
NSLog("%d", loc);

điều này cũng làm việc

var myRange: NSRange = "abcdefghi".rangeOfString("c")
var loc = myRange.location
NSLog("%d", loc);

Cả hai điều này dường như dự phòng cho hành vi của NSString bằng cách nào đó. Trong sân chơi của tôi, tôi đã sử dụng một biến trung gian cho chuỗi. var str = "abcdef"; str.rangeOfString("c").locationgây ra lỗi về String. Index không có thành viên có tên là vị trí ...
Matt Wishing

1
Nó hoạt động chỉ vì "chuỗi" là NSString chứ không phải Chuỗi của Swift
gderaco

2

Chuỗi loại biến trong Swift chứa các hàm khác nhau so với NSString trong Objective-C. Và như Sulthan đã đề cập,

Chuỗi Swift không triển khai RandomAccess Index

Những gì bạn có thể làm là hạ thấp biến loại String thành NSString của bạn (điều này hợp lệ trong Swift). Điều này sẽ cung cấp cho bạn quyền truy cập vào các chức năng trong NSString.

var str = "abcdefghi" as NSString
str.rangeOfString("c").locationx   // returns 2

2

Nếu bạn nghĩ về nó, bạn thực sự không cần phiên bản Int chính xác của địa điểm. Phạm vi hoặc thậm chí String.Index là đủ để lấy lại chuỗi con nếu cần:

let myString = "hello"

let rangeOfE = myString.rangeOfString("e")

if let rangeOfE = rangeOfE {
    myString.substringWithRange(rangeOfE) // e
    myString[rangeOfE] // e

    // if you do want to create your own range
    // you can keep the index as a String.Index type
    let index = rangeOfE.startIndex
    myString.substringWithRange(Range<String.Index>(start: index, end: advance(index, 1))) // e

    // if you really really need the 
    // Int version of the index:
    let numericIndex = distance(index, advance(index, 1)) // 1 (type Int)
}

Câu trả lời tốt nhất cho tôi là func indexOf (target: String) -> Int {return (self as NSString) .rangeOfString (target) .location}
YannSteph

2

Cách đơn giản nhất là:

Trong Swift 3 :

 var textViewString:String = "HelloWorld2016"
    guard let index = textViewString.characters.index(of: "W") else { return }
    let mentionPosition = textViewString.distance(from: index, to: textViewString.endIndex)
    print(mentionPosition)

1

Chuỗi là một loại cầu cho NSString, vì vậy hãy thêm

import Cocoa

vào tập tin nhanh chóng của bạn và sử dụng tất cả các phương pháp "cũ".


1

Về mặt suy nghĩ, điều này có thể được gọi là HÓA ĐƠN. Bạn khám phá thế giới tròn thay vì bằng phẳng. "Bạn không thực sự cần phải biết INDEX của nhân vật để làm mọi thứ với nó." Và là một lập trình viên C, tôi thấy rằng cũng khó để lấy quá! Dòng của bạn "let index = Letters.char character.indexOf (" c ")!" là đủ của chính nó. Ví dụ: để xóa c bạn có thể sử dụng ... (dán sân chơi)

    var letters = "abcdefg"
  //let index = letters.rangeOfString("c")!.startIndex //is the same as
    let index = letters.characters.indexOf("c")!
    range = letters.characters.indexOf("c")!...letters.characters.indexOf("c")!
    letters.removeRange(range)
    letters

Tuy nhiên, nếu bạn muốn một chỉ mục, bạn cần trả về INDEX thực tế chứ không phải Int vì giá trị Int sẽ yêu cầu các bước bổ sung cho bất kỳ việc sử dụng thực tế nào. Các tiện ích mở rộng này trả về một chỉ mục, số lượng ký tự cụ thể và phạm vi mà mã có thể bổ trợ của sân chơi này sẽ thể hiện.

extension String
{
    public func firstIndexOfCharacter(aCharacter: Character) -> String.CharacterView.Index? {

        for index in self.characters.indices {
            if self[index] == aCharacter {
                return index
            }

        }
        return nil
    }

    public func returnCountOfThisCharacterInString(aCharacter: Character) -> Int? {

        var count = 0
        for letters in self.characters{

            if aCharacter == letters{

                count++
            }
        }
        return count
    }


    public func rangeToCharacterFromStart(aCharacter: Character) -> Range<Index>? {

        for index in self.characters.indices {
            if self[index] == aCharacter {
                let range = self.startIndex...index
                return range
            }

        }
        return nil
    }

}



var MyLittleString = "MyVery:important String"

var theIndex = MyLittleString.firstIndexOfCharacter(":")

var countOfColons = MyLittleString.returnCountOfThisCharacterInString(":")

var theCharacterAtIndex:Character = MyLittleString[theIndex!]

var theRange = MyLittleString.rangeToCharacterFromStart(":")
MyLittleString.removeRange(theRange!)

1

Giải pháp hoàn chỉnh Swift 4:

Offset IndexableCollection (Chuỗi sử dụng Int Index)

https://github.com/frogcjn/ Offerset IndexableCollection-String-Int- Indexable-

let a = "01234"

print(a[0]) // 0
print(a[0...4]) // 01234
print(a[...]) // 01234

print(a[..<2]) // 01
print(a[...2]) // 012
print(a[2...]) // 234
print(a[2...3]) // 23
print(a[2...2]) // 2

if let number = a.index(of: "1") {
    print(number) // 1
    print(a[number...]) // 1234
}

if let number = a.index(where: { $0 > "1" }) {
    print(number) // 2
}

1

chuỗi mở rộng {

//Fucntion to get the index of a particular string
func index(of target: String) -> Int? {
    if let range = self.range(of: target) {
        return characters.distance(from: startIndex, to: range.lowerBound)
    } else {
        return nil
    }
}
//Fucntion to get the last index of occurence of a given string
func lastIndex(of target: String) -> Int? {
    if let range = self.range(of: target, options: .backwards) {
        return characters.distance(from: startIndex, to: range.lowerBound)
    } else {
        return nil
    }
}

}


1

Swift 5

Tìm chỉ mục của chuỗi con

let str = "abcdecd"
if let range: Range<String.Index> = str.range(of: "cd") {
    let index: Int = str.distance(from: str.startIndex, to: range.lowerBound)
    print("index: ", index) //index: 2
}
else {
    print("substring not found")
}

Tìm chỉ số của nhân vật

let str = "abcdecd"
if let firstIndex = str.firstIndex(of: "c") {
    let index: Int = str.distance(from: str.startIndex, to: firstIndex)
    print("index: ", index)   //index: 2
}
else {
    print("symbol not found")
}


0

Để lấy chỉ mục của chuỗi con trong chuỗi bằng Swift 2:

let text = "abc"
if let range = text.rangeOfString("b") {
   var index: Int = text.startIndex.distanceTo(range.startIndex) 
   ...
}

0

Trong swift 2.0

var stringMe="Something In this.World"
var needle="."
if let idx = stringMe.characters.indexOf(needle) {
    let pos=stringMe.substringFromIndex(idx)
    print("Found \(needle) at position \(pos)")
}
else {
    print("Not found")
}

0
let mystring:String = "indeep";
let findCharacter:Character = "d";

if (mystring.characters.contains(findCharacter))
{
    let position = mystring.characters.indexOf(findCharacter);
    NSLog("Position of c is \(mystring.startIndex.distanceTo(position!))")

}
else
{
    NSLog("Position of c is not found");
}

0

Tôi chơi theo

extension String {
    func allCharactes() -> [Character] {
         var result: [Character] = []
         for c in self.characters {
             result.append(c)
         }
         return 
    }
}

cho đến khi tôi hiểu người được cung cấp bây giờ thì đó chỉ là mảng Ký tự

và với

let c = Array(str.characters)

Điều này thực hiện được những gì? Làm thế nào là khối mã đầu tiên của bạn tốt hơn khối thứ hai?
Ben Leggiero

0

Nếu bạn chỉ cần chỉ mục của một ký tự, giải pháp đơn giản, nhanh chóng nhất (như đã được Pascal chỉ ra) là:

let index = string.characters.index(of: ".")
let intIndex = string.distance(from: string.startIndex, to: index)

bây giờ các ký tự bị mất giá ... thật đáng buồn, ngay cả khi điều này hoạt động
dùng3069232

0

Về chủ đề biến một String.Indexthành một Int, phần mở rộng này hoạt động với tôi:

public extension Int {
    /// Creates an `Int` from a given index in a given string
    ///
    /// - Parameters:
    ///    - index:  The index to convert to an `Int`
    ///    - string: The string from which `index` came
    init(_ index: String.Index, in string: String) {
        self.init(string.distance(from: string.startIndex, to: index))
    }
}

Ví dụ sử dụng liên quan đến câu hỏi này:

var testString = "abcdefg"

Int(testString.range(of: "c")!.lowerBound, in: testString)     // 2

testString = "🇨🇦🇺🇸🇩🇪👩‍👩‍👧‍👦\u{1112}\u{1161}\u{11AB}"

Int(testString.range(of: "🇨🇦🇺🇸🇩🇪")!.lowerBound, in: testString) // 0
Int(testString.range(of: "👩‍👩‍👧‍👦")!.lowerBound, in: testString)    // 1
Int(testString.range(of: "한")!.lowerBound, in: testString)    // 5

Quan trọng:

Như bạn có thể nói, nó nhóm các cụm grapheme mở rộng và các ký tự được nối khác nhau hơn String.Index. Tất nhiên, đây là lý do tại sao chúng ta có String.Index. Bạn nên nhớ rằng phương pháp này coi các cụm là các ký tự số ít, gần với chính xác hơn. Nếu mục tiêu của bạn là phân tách một chuỗi bằng mã hóa Unicode, đây không phải là giải pháp cho bạn.


0

Trong Swift 2.0 , hàm sau trả về một chuỗi con trước một ký tự đã cho.

func substring(before sub: String) -> String {
    if let range = self.rangeOfString(sub),
        let index: Int = self.startIndex.distanceTo(range.startIndex) {
        return sub_range(0, index)
    }
    return ""
}

0

Bạn có thể tìm thấy số chỉ mục của một ký tự trong chuỗi bằng:

var str = "abcdefghi"
if let index = str.firstIndex(of: "c") {
    let distance = str.distance(from: str.startIndex, to: index)
    // distance is 2
}

0

Theo quan điểm của tôi, cách tốt hơn để biết chính logic là bên dưới

 let testStr: String = "I love my family if you Love us to tell us I'm with you"
 var newStr = ""
 let char:Character = "i"

 for value in testStr {
      if value == char {
         newStr = newStr + String(value)
   }

}
print(newStr.count)
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.