Fatal编程技术网
  • swift/
  • 如何在Swift 4中使用字符串子字符串'；子串（to:）&x27；已弃用：请使用带'；部分范围为'；操作人员

如何在Swift 4中使用字符串子字符串'；子串（to:）&x27；已弃用：请使用带'；部分范围为'；操作人员

swift

如何在Swift 4中使用字符串子字符串'；子串（to:）&x27；已弃用：请使用带'；部分范围为'；操作人员,swift,swift4,Swift,Swift4,我用Swift 3编写了以下简单代码： let str = "Hello, playground" let index = str.index(of: ",")! let newStr = str.substring(to: index) 从Xcode 9 beta 5中，我得到以下警告： “substring（to:）”已被弃用：请使用带有“部分范围从”运算符的String切片下标 如何在Swift 4中使用部分范围为的切片下标？您应该将一侧保留为空，因此命名为“部分范围” 请记住，这些范围

我用Swift 3编写了以下简单代码：

let str = "Hello, playground"
let index = str.index(of: ",")!
let newStr = str.substring(to: index)
从Xcode 9 beta 5中，我得到以下警告：

“
substring（to:）
”已被弃用：请使用带有“部分范围从”运算符的
String
切片下标

如何在Swift 4中使用部分范围为的切片下标？

您应该将一侧保留为空，因此命名为“部分范围”

请记住，这些范围运算符返回一个子字符串
。如果要将其转换为字符串，请使用
string
的初始化功能：


let newStr = String(str[..<index])



let newStr=String（str[…Swift3和Swift4中的
uppercasedFirstCharacter
便利属性示例

属性
uppercasedFirstCharacterNew
演示如何在Swift4中使用字符串切片下标


extension String {

   public var uppercasedFirstCharacterOld: String {
      if characters.count > 0 {
         let splitIndex = index(after: startIndex)
         let firstCharacter = substring(to: splitIndex).uppercased()
         let sentence = substring(from: splitIndex)
         return firstCharacter + sentence
      } else {
         return self
      }
   }

   public var uppercasedFirstCharacterNew: String {
      if characters.count > 0 {
         let splitIndex = index(after: startIndex)
         let firstCharacter = self[..<splitIndex].uppercased()
         let sentence = self[splitIndex...]
         return firstCharacter + sentence
      } else {
         return self
      }
   }
}

let lorem = "lorem".uppercasedFirstCharacterOld
print(lorem) // Prints "Lorem"

let ipsum = "ipsum".uppercasedFirstCharacterNew
print(ipsum) // Prints "Ipsum"



扩展字符串{
公共变量uppercasedFirstCharacterOld:字符串{
如果characters.count>0{
让splitIndex=索引（在：startIndex之后）
让firstCharacter=substring（to:splitIndex）.uppercased（）
让句子=子字符串（from:splitIndex）
返回第一个字符+句子
}否则{
回归自我
}
}
公共变量uppercasedFirstCharacterNew:字符串{
如果characters.count>0{
让splitIndex=索引（在：startIndex之后）

让firstCharacter=self[…也可以通过以下方式将代码转换为Swift 4：


let str = "Hello, playground"
let index = str.index(of: ",")!
let substr = str.prefix(upTo: index)


您可以使用以下代码创建新字符串：


let newString = String(str.prefix(upTo: index))


子字符串（从：索引）转换为[index…]

检查样品


let text = "1234567890"
let index = text.index(text.startIndex, offsetBy: 3)

text.substring(from: index) // "4567890"   [Swift 3]
String(text[index...])      // "4567890"   [Swift 4]



一些有用的扩展：


extension String {
    func substring(from: Int, to: Int) -> String {
        let start = index(startIndex, offsetBy: from)
        let end = index(start, offsetBy: to - from)
        return String(self[start ..< end])
    }

    func substring(range: NSRange) -> String {
        return substring(from: range.lowerBound, to: range.upperBound)
    }
}



扩展字符串{
func子字符串（from:Int，to:Int）->String{
让开始=索引（开始索引，偏移：起始）
让结束=索引（开始，偏移：到-从）
返回字符串（self[start..字符串{
返回子字符串（从：range.lowerBound到：range.upperBound）
}
}

将子字符串（Swift 3）转换为字符串切片（Swift 4）

Swift 3、4中的示例：


let newStr = str.substring(to: index) // Swift 3
let newStr = String(str[..<index]) // Swift 4





let range=firstIndex..Swift 5,4
用法

let text=“你好，世界”
text[0]//H
文本[…3]/“地狱”
文本[6..字符{
self[索引（at:value）]
}
}
公共扩展字符串{
下标（值：NSRange）->子字符串{
self[value.lowerBound..Substring{
self[索引（at:value.lowerBound）…索引（at:value.upperBound）]
}
下标（值：CountableRange）->子字符串{
self[index（at:value.lowerBound）…子字符串{
自[…子串{
self[…索引（at:value.upperBound）]
}
下标（值：PartialRangeFrom）->子字符串{
self[索引（at:value.lowerBound）…]
}
}
专用扩展字符串{
func索引（偏移量：Int）->String.index{
索引（startIndex，offsetBy:offset）
}
}

在编程时，我经常使用带有普通A-Za-z和0-9的字符串。不需要复杂的索引操作。此扩展基于普通的旧左/中/右函数


extension String {

    // LEFT
    // Returns the specified number of chars from the left of the string
    // let str = "Hello"
    // print(str.left(3))         // Hel
    func left(_ to: Int) -> String {
        return "\(self[..<self.index(startIndex, offsetBy: to)])"
    }

    // RIGHT
    // Returns the specified number of chars from the right of the string
    // let str = "Hello"
    // print(str.left(3))         // llo
    func right(_ from: Int) -> String {
        return "\(self[self.index(startIndex, offsetBy: self.length-from)...])"
    }

    // MID
    // Returns the specified number of chars from the startpoint of the string
    // let str = "Hello"
    // print(str.left(2,amount: 2))         // ll
    func mid(_ from: Int, amount: Int) -> String {
        let x = "\(self[self.index(startIndex, offsetBy: from)...])"
        return x.left(amount)
    }
}



扩展字符串{
//左
//从字符串左侧返回指定数量的字符
//让str=“你好”
//打印（str.left（3））//Hel
func left（u-to:Int）->字符串{

return“\（self[…这是我的解决方案，没有警告，没有错误，但很完美


let redStr: String = String(trimmStr[String.Index.init(encodedOffset: 0)..<String.Index.init(encodedOffset: 2)])
let greenStr: String = String(trimmStr[String.Index.init(encodedOffset: 3)..<String.Index.init(encodedOffset: 4)])
let blueStr: String = String(trimmStr[String.Index.init(encodedOffset: 5)..<String.Index.init(encodedOffset: 6)])



let redStr:String=String（trimmStr[String.Index.init（encodedOffset:0）…


extension String {
    
    func sliceByCharacter(from: Character, to: Character) -> String? {
        let fromIndex = self.index(self.index(of: from)!, offsetBy: 1)
        let toIndex = self.index(self.index(of: to)!, offsetBy: -1)
        return String(self[fromIndex...toIndex])
    }
    
    func sliceByString(from:String, to:String) -> String? {
        //From - startIndex
        var range = self.range(of: from)
        let subString = String(self[range!.upperBound...])
        
        //To - endIndex
        range = subString.range(of: to)
        return String(subString[..<range!.lowerBound])
    }
    
}



扩展字符串{
func sliceByCharacter（from:Character，to:Character）->字符串{
设fromIndex=self.index（self.index（of:from）！，偏移量：1）
设toIndex=self.index（self.index（of:to）！，偏移量：-1）
返回字符串（self[从索引…到索引]）
}
func sliceByString（from:String，to:String）->String{
//From-startIndex
var范围=自身范围（of:from）
让subString=String（self[range！.upperBound…）
//结束索引
范围=子字符串。范围（of:to）
返回字符串（子字符串[…使用Swift 4从字符串创建子字符串（前缀和后缀）：
如果要在两个索引之间生成子字符串，请使用：

let substring1=string[startIndex…endIndex]//包括endIndex

让subString2=string[startIndex..您可以使用类字符串的扩展创建自定义子字符串方法，如下所示：


extension String {
    func subString(startIndex: Int, endIndex: Int) -> String {
        let end = (endIndex - self.count) + 1
        let indexStartOfText = self.index(self.startIndex, offsetBy: startIndex)
        let indexEndOfText = self.index(self.endIndex, offsetBy: end)
        let substring = self[indexStartOfText..<indexEndOfText]
        return String(substring)
    }
}



扩展字符串{
func子字符串（startIndex:Int，endIndex:Int）->String{
让end=（endIndex-self.count）+1
让indexStartOfText=self.index（self.startIndex，offsetBy:startIndex）
让indexEndOfText=self.index（self.endIndex，offsetBy:end）

让substring=self[indexStartOfText..希望这对您的帮助不大：-


var string = "123456789"


如果您想在某个特定索引后使用子字符串


var indexStart  =  string.index(after: string.startIndex )// you can use any index in place of startIndex
var strIndexStart   = String (string[indexStart...])//23456789


如果在删除末尾的一些字符串后需要一个子字符串


var indexEnd  =  string.index(before: string.endIndex)
var strIndexEnd   = String (string[..<indexEnd])//12345678


Swift 4/5中的较短版本：


var string = "123456"
string = String(string.prefix(3)) //"123"
string = String(string.suffix(3)) //"456"



使用此方法，您可以获得字符串的特定范围。您需要传递起始索引，然后传递所需的字符总数


extension String{
    func substring(fromIndex : Int,count : Int) -> String{
        let startIndex = self.index(self.startIndex, offsetBy: fromIndex)
        let endIndex = self.index(self.startIndex, offsetBy: fromIndex + count)
        let range = startIndex..<endIndex
        return String(self[range])
    }
}



扩展字符串{
func子字符串（fromIndex:Int，count:Int）->字符串{
设startIndex=self.index（self.startIndex，offsetBy:fromIndex）
让endIndex=self.index（self.startIndex，offsetBy:fromIndex+count）

让range=startIndex..希望这会有帮助


extension String {
    func getSubString(_ char: Character) -> String {
        var subString = ""
        for eachChar in self {
            if eachChar == char {
                return subString
            } else {
                subString += String(eachChar)
            }
        }
        return subString
    }
}


let str: String = "Hello, playground"
print(str.getSubString(","))


迅捷5
（Java的子字符串方法）：

var str=“你好，游乐场”
设indexcut=str.firstIndex（of:“，”）

print（String）（str[…
str[…使用字符串插值和一个单独的
Substring
可能会有点混淆，因为您真正想要完成的是
String
初始化：
let newStr=String（str[…更新代码，其中我的'index'值只是一个整数

prefix , suffix : ilike
prefix i, suffix : like
prefix il, suffix : ike
prefix ili, suffix : ke
prefix ilik, suffix : e
prefix ilike, suffix : 



let substring1 = string[startIndex...endIndex] // including endIndex
let subString2 = string[startIndex..<endIndex] // excluding endIndex



extension String {
    func subString(startIndex: Int, endIndex: Int) -> String {
        let end = (endIndex - self.count) + 1
        let indexStartOfText = self.index(self.startIndex, offsetBy: startIndex)
        let indexEndOfText = self.index(self.endIndex, offsetBy: end)
        let substring = self[indexStartOfText..<indexEndOfText]
        return String(substring)
    }
}



var string = "123456789"



var indexStart  =  string.index(after: string.startIndex )// you can use any index in place of startIndex
var strIndexStart   = String (string[indexStart...])//23456789



var indexEnd  =  string.index(before: string.endIndex)
var strIndexEnd   = String (string[..<indexEnd])//12345678



var  indexWithOffset =  string.index(string.startIndex, offsetBy: 4)



var string = "123456"
string = String(string.prefix(3)) //"123"
string = String(string.suffix(3)) //"456"



extension String{
    func substring(fromIndex : Int,count : Int) -> String{
        let startIndex = self.index(self.startIndex, offsetBy: fromIndex)
        let endIndex = self.index(self.startIndex, offsetBy: fromIndex + count)
        let range = startIndex..<endIndex
        return String(self[range])
    }
}



extension String {
    func getSubString(_ char: Character) -> String {
        var subString = ""
        for eachChar in self {
            if eachChar == char {
                return subString
            } else {
                subString += String(eachChar)
            }
        }
        return subString
    }
}


let str: String = "Hello, playground"
print(str.getSubString(","))



extension String {
    func subString(from: Int, to: Int) -> String {
       let startIndex = self.index(self.startIndex, offsetBy: from)
       let endIndex = self.index(self.startIndex, offsetBy: to)
       return String(self[startIndex..<endIndex])
    }
}



var str = "Hello, Nick Michaels"
print(str.subString(from:7,to:20))
// print Nick Michaels



var str = "Hello, playground"
let indexcut = str.firstIndex(of: ",")
print(String(str[..<indexcut!]))
print(String(str[indexcut!...]))