How do I get part of a string in swift?

Question

I would like to find out how to get a part of a string in Swift. I am looking for the Swift equivalents of the Mid$, Right$, and Left$ functions. Any help would be appreciated.

Answer 1

Swift 4, Swift5

Modern API has got this syntax:

let str = "Hello world!"
let prefix = String(str.prefix(1))
let suffix = String(str.suffix(1))

Answer 2

Edit: This answer was from 2014 and is obsolete today, I recommend referencing Vyacheslav's answer instead

The equivalent of Left is substringToIndex

Example: (directly from this site)

let myString = "ABCDEFGHI"
let mySubstring = (myString.substringToIndex(2))
//This grabs the first 2 digits of the string and stops there,
//which returns "AB"

The (rough) equivalent of Right is substringFromIndex

Example: (directly from the same site)

let myString = "ABCDEFGHI"
let mySubstring = (myString.substringFromIndex(2))
//This jumps over the first 2 digits of the string and grabs the rest,
//which returns "CDEFGHI"

See https://web.archive.org/web/20170504165315/http://www.learnswiftonline.com/reference-guides/string-reference-guide-for-swift/

Answer 3

Here are my versions of rightString, leftString and midString functions based on Aristocrates answer.

var myString = "abcdefghijklmnopqrstuvwxyz987654321"

func leftString(theString: String, charToGet: Int) ->String{

var indexCount = 0
let strLen = countElements(theString)

if charToGet > strLen { indexCount = strLen } else { indexCount = charToGet }
if charToGet < 0 { indexCount = 0 }

let index: String.Index = advance(theString.startIndex, indexCount)
let mySubstring:String = theString.substringToIndex(index)

return mySubstring
}

func rightString(theString: String, charToGet: Int) ->String{

var indexCount = 0
let strLen = countElements(theString)
var charToSkip = strLen - charToGet

if charToSkip > strLen { indexCount = strLen } else { indexCount = charToSkip }
if charToSkip < 0 { indexCount = 0 }

let index: String.Index = advance(theString.startIndex, indexCount)
let mySubstring:String = theString.substringFromIndex(index)

return mySubstring
}

func midString(theString: String, startPos: Int, charToGet: Int) ->String{

let strLen = countElements(theString)
var rightCharCount = strLen - startPos

var mySubstring = rightString(theString, rightCharCount)
 mySubstring = leftString(mySubstring, charToGet)

return mySubstring
}

var myLeftString = leftString(myString, 3)
// returns "abc"

var myRightString = rightString(myString, 5)
// returns "54321"

var myMidString = midString(myString, 3, 5)
// returns "defgh"

Answer 4

In Swift 4 the equivalents to Left() and right() are prefix() and suffix(). The Mid() equivalent is missing. I would expect a function called something like infix(position:length).

Answer 5

The solutions here all seemed out of date. This is what I ended up with for getting the left and right sides of a string with a number of characters in Swift 2.0:

public extension String
{


    public var length: Int { return self.characters.count }  // Swift 2.0


    public func substringToCharactersCount(count: Int) -> String?
    {
        // Discussion:  Equivalent to "left".  Gets the beginning portion of the string with the specified number of characters.  It is friendly to having a count that exceeds the length of the string, returning the portion that it can.

        // returnString
        var returnString: String?

        // length
        let length = self.length

        if length > 0
        {
            // useCount
            let useCount: Int

            if count > length
            {
                useCount = length
            }
            else
            {
                useCount = count
            }

            if useCount > 0
            {
                // useEndIndex
                let useEndIndex = self.startIndex.advancedBy(useCount)

                returnString = self.substringToIndex(useEndIndex)
            }
        }

        return returnString
    }



    public func substringFromCharactersCount(count: Int) -> String?
    {
        // Discussion:  Equivalent to "right".  Gets the ending portion of the string with the specified number of characters.  It is friendly to having a count that exceeds the length of the string, returning the portion that it can.

        // returnString
        var returnString: String?

        // length
        let length = self.length

        if length > 0
        {
            // useCount
            let useCount: Int

            if count > length
            {
                useCount = length
            }
            else
            {
                useCount = count
            }

            if useCount > 0
            {
                // useStartIndex
                let useStartIndex = self.startIndex.advancedBy(length - useCount)

                returnString = self.substringFromIndex(useStartIndex)
            }
        }

        return returnString
    }



}