Convert ISBN10 to ISBN13 Looking to confirm that I am doing this in the most efficient way.

func convrtisbn10(isbn: String) {
    var checkSum: Int = 0
    var completeISBN = ""
    let newISBN = "978" + "\(isbn)"
    let result = String(newISBN.characters.dropLast(1))
    var oddSum = 0, evenSum = 0
    let reversedArray = result.characters

    for (i, s) in reversedArray.enumerate() {

        let digit = Int(String(s))!

        if i % 2 == 0 {
            evenSum += digit
        } else {
            oddSum += digit * 3
        }
    }
    let total = evenSum + oddSum
    let remander = total % 10
    if (10 - remander) == 10 {
        checkSum = 0
    } else {
        checkSum = 10 - remander
        completeISBN = result + "\(checkSum)"
    }
    getBookInfo(completeISBN)

}
It is not apparent from the function name convrtisbn10 what the 
function does. Does is convert from or to ISBN-10, and from or to what?
And why does a conversion function not return anything?
You are calling getBookInfo(completeISBN) at the end of the function: 
Whatever that is, it should not be part of the conversion.

The validity of the input string is not verified. If the input is too
short or too long, the result will be nonsense. If the input contains
non-digits, the function will crash. 

A better function definition might be

func convertToISBN13(isbn10: String) -&gt; String?


where the argument name indicates that is is a ISBN-10 and the function
name indicates that it is converted to a ISBN-13. The return value
is an optional, so that we can return nil for invalid input.
(An alternative would be to throw an error for invalid input.)

The type annotation in

var checkSum: Int = 0


is not necessary, also variables should be declared at the narrowest
scope where they are needed.

Setting an initial value for

var completeISBN = ""


hides an error in your program: 

if (10 - remander) == 10 {
    checkSum = 0
} else {
    checkSum = 10 - remander
    completeISBN = result + "\(checkSum)"
}


In the first case the checksum is not appended to the ISBN.
The compiler does not notice that because completeISBN has a
defined value.

The string interpolation in

let newISBN = "978" + "\(isbn)"


is not necessary because isbn is already a string:

let newISBN = "978" + isbn


The variables

var oddSum = 0, evenSum = 0


are not needed, all calculations can update  checkSum directly.

It is not necessary to process the characters in reverse order.
Just process them starting with the first one (and use multiplier 3
for odd indices).

As said above,

    let digit = Int(String(s))!


would abort the program execution if s is not a number, this
should be checked.

I would move the calculation of the ISBN-13 checksum to
a separate function, which can then be used independently to
calculate or verify checksums. 

Putting all this together, the code could look like this:

func checksumISBN13(isbn13: String) -&gt; Int? {
    var checksum = 0
    for (position, char) in isbn13.characters.enumerated() {
        guard let digit = Int(String(char)) else {
            return nil
        }
        if position % 2 == 0 {
            checksum += digit
        } else {
            checksum += 3 * digit
        }
    }
    let remainder = checksum % 10
    if remainder == 0 {
        return 0
    } else {
        return 10 - remainder
    }
}

func convertToISBN13(isbn10: String) -&gt; String? {

    guard isbn10.characters.count == 10 else {
        return nil
    }
    let isbn13 = "978" + String(isbn10.characters.dropLast())
    guard let checksum = checksumISBN13(isbn13: isbn13) else {
        return nil
    }
    return isbn13 + String(checksum)
}


Finally, note that ISBNs are usually printed in groups with a separator
(e.g. "978-3-86680-192-9"), so another suggestion is to


tolerate (not require) separator characters in the input string, and
create the output string in the grouped format.




A more universal approach would be to define a ISBN type which
can be initialized from both ISBN-10 and ISBN-13 strings (with
or without checksums). Just to give you an idea:

public struct ISBN: CustomStringConvertible {
    private let digits: [Int] // 13 digits

    public init?(isbn13: String) {
        // Verify that `isbn13` has 12 or 13 characters (ignoring separators)
        // Fill `digits`.
        // If 12 digits: append checksum.
        // If 13 digits: verify checksum.
    }

    public init?(isbn10: String) {
        // Verify that `isbn10` has 9 or 10 characters (ignoring separators)
        // Remove last character (checksum) if present.
        self.init(isbn13: "978" + isbn10)
    }

    var description: String {
        // Create and return formatted string description
    }
}