How to check whether a string is Base64 encoded or not
You can use the following regular expression to check if a string constitutes a valid base64 encoding:
^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)?$
In base64 encoding, the character set is [A-Z, a-z, 0-9, and + /]
. If the rest length is less than 4, the string is padded with '='
characters.
^([A-Za-z0-9+/]{4})*
means the string starts with 0 or more base64 groups.
([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$
means the string ends in one of three forms: [A-Za-z0-9+/]{4}
, [A-Za-z0-9+/]{3}=
or [A-Za-z0-9+/]{2}==
.
It is possible to know if a string is encoded in base64?
There is no need to check in advance if the string contains valid
Base-64. You just have to check the return value, which is nil
when the input is not recognized as valid Base-64:
if let decodedData = NSData(base64EncodedString: someString, options: nil) {
// ...
} else {
println("Not Base64")
}
Update for Swift 4:
if let decodedData = Data(base64Encoded: someString) {
// ...
} else {
print("Not Base64")
}
Determine if string is in base64 using JavaScript
If "valid" means "only has base64 chars in it" then check against /[A-Za-z0-9+/=]/
.
If "valid" means a "legal" base64-encoded string then you should check for the =
at the end.
If "valid" means it's something reasonable after decoding then it requires domain knowledge.
Check if a string is encoded in base64 using Python
This isn't possible. The best you could do would be to verify that a string might be valid Base 64, although many strings consisting of only ASCII text can be decoded as if they were Base 64.
How to check whether a string is base64 encoded or not?
If you receive the exact value by <img src="..." />
attribute then it should have Data URL format
The simple regexp could determine whether the URL is Data or regular. In java it can look like
private static final Pattern DATA_URL_PATTERN = Pattern.compile("^data:image/(.+?);base64,\\s*", Pattern.CASE_INSENSITIVE);
static void handleImgSrc(String path) {
if (path.startsWith("data:")) {
final Matcher m = DATA_URL_PATTERN.matcher(path);
if (m.find()) {
String imageType = m.group(1);
String base64 = path.substring(m.end());
// decodeImage(imageType, base64);
} else {
// some logging
}
} else {
// downloadImage(path);
}
}
How to check for a valid Base64 encoded string
Update: For newer versions of C#, there's a much better alternative, please refer to the answer by Tomas here: https://stackoverflow.com/a/54143400/125981.
It's pretty easy to recognize a Base64 string, as it will only be composed of characters 'A'..'Z', 'a'..'z', '0'..'9', '+', '/'
and it is often padded at the end with up to three '=', to make the length a multiple of 4. But instead of comparing these, you'd be better off ignoring the exception, if it occurs.
Detect if Base 64 string is image or text
You can't generally just look at the base 64 string and decide, but you can decode the first few bytes of data, look at the hex codes (you can do this by decoding your base-64 string into a NSData
and just NSLog
it or examining it in the debugger), and draw some conclusions. For example:
Image files generally start with special byte sequences (e.g. JPEG start with the hex bytes
FF D8
; PNG generally start with hex bytes89 50 4E 47 0D 0A 1A 0A
(e.g.89 "PNG" CR LF EOF LF
, etc.). Note, there are a dizzying number of different image formats, so this is a non-trivial exercise, but sometimes you can get lucky and it will be self-evident that it's one of these common format when you glance at the first few bytes.NSKeyedArchiver
archives generally start with the string "bplist
".ASCII text consists of codes between
20
and7F
(with linefeeds represented by0A
; carriage return and linefeeds represented byOD 0A
; tab characters as09
; etc.). Then, again, if it was a text, it's unlikely they'd be base-64 encoding it.If it was UTF-8 it would conform to the coding pattern outlined here. For example, you can look at the first few high bits of the first byte that might conceivably represent a UTF-8 character, and conclude (a) how many bytes the character is represented by and (b) what high bits will be turned on those subsequent bytes. You can often quickly look at it and confirm whether the data conforms to this UTF-8 pattern or not (especially easy to do for most western languages)
If the first three characters were
EF BB BF
, that often indicates a UTF-8 byte order mark.
This is, by no means, an exhaustive list of codes, but just a few that leapt out at me.
To do this programmatically and do so exhaustively would be a non-trivial exercise. But if you're just "eye-balling" a base-64 string and trying to draw some logical inferences, decode it and look at the hex bytes and you can quickly narrow down the possibilities, at the very least. If you're unsure about how to interpret it, update your question with the hex representation of the decoded base-64 string (just the first 16-32 bytes, please), and we might be able to point you in the right direction.
Related Topics
(Swift Spritekit) Rotate Sprite in the Direction of Touch
Today Extension with Uicollectionview Different Behaviour Compared to Single View Application
Convenience Initialization of Uinavigationcontroller Subclass Makes Subclass Constant Init Twice
Show Bounding Box While Detecting Object Using Arkit 2
Use More Than One Firebase Database in Single App - Swift
Avcapturestillimageoutput VS Avcapturephotooutput in Swift 3
Get Latitude and Longitude Center of Google Map
How to Enable Only Numeric Digit Keyboard iOS Swift
Swift Lazy and Optional Properties
Xcode 6 & Swift: Black Bars Appear Above and Below the Viewcontroller on iOS 7 iPhone 5 Device
Swift, Parse.Com: How to Pass Data from Query
How to Get the User "Name" Using Swift
Start/Stop Image View Rotation Animations
iOS Swift. How to Get a Gps Metadata from Just a Uiimage (Nsurl)
Avcapturesession and Avaudiosession Recording Video While Background Music Playing Only Works Once