下面是一个干净的String扩展，回答了这个问题:

斯威夫特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
    }
}

斯威夫特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
    }
}

extension String{
    func contains(find: String)->Bool{
        return self.range(of: find) != nil
    }
}
 
func check(n:String, h:String)->Int{
    let n1 = n.lowercased()
    let h1 = h.lowercased()//lowercase to make string case insensitive
    var pos = 0 //postion of substring
    if h1.contains(n1){
       // checking if sub string exists
        if let idx = h1.firstIndex(of:n1.first!){
             let pos1 = h1.distance(from: h1.startIndex, to: idx)
           pos = pos1
        }
        return pos
    }
    else{
        return -1
    }
}
 
print(check(n:"@", h:"hithisispushker,he is 99 a good Boy"))//put substring in n: and string in h

与Objective-C中的NSString相比，Swift中的变量类型String包含不同的函数。Sulthan提到过，

Swift String没有实现RandomAccessIndex

你能做的是向下转换你的变量类型String到NSString(这是有效的Swift)。这将给你访问NSString中的函数。

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

String是NSString的桥接类型，add

import Cocoa

到你的swift文件，并使用所有“旧”的方法。

在思考方面，这可能被称为反转。你会发现世界是圆的而不是平的。“你真的不需要知道角色的索引来处理它。”作为一名C程序员，我发现这也很难接受! 你的行“let index = letters.characters.indexOf("c")!”本身就足够了。 例如，要去掉c，你可以用…(操场粘贴)

    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

然而，如果你想要一个索引，你需要返回一个实际的index而不是Int值，因为Int值对于任何实际使用都需要额外的步骤。这些扩展返回一个索引，一个特定字符的计数，以及这个游乐场插件代码将演示的范围。

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!)

仔细想想，你其实并不需要位置的确切Int版本。范围甚至是字符串。如果需要，Index足以再次获取子字符串:

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)
}