0
# Version and Testing Utilities
1

2
Advanced functionality for version extraction, device testing, and pattern matching against User-Agent strings.
3

4
## Capabilities
5

6
### Version Extraction
7

8
Extract numeric and string versions of various components from the User-Agent string.
9

10
```javascript { .api }
11
/**
12
 * Get the version (as Number) of the given property in the User-Agent
13
 * @param key - A key defining a thing which has a version (case-insensitive)
14
 *              Supported keys: Mobile, Build, Version, VendorID, browser names, OS names
15
 * @returns The version as floating-point Number (e.g., 91.0, 14.6) or NaN if version is not found
16
 */
17
version(key: string): number;
18

19
/**
20
 * Get the version (as String) of the given property in the User-Agent  
21
 * @param key - A key defining a thing which has a version (case-insensitive)
22
 *              Same supported keys as version() method
23
 * @returns The "raw" version as String (e.g., '91.0.4472.124', '14_6') or null if version is not found
24
 */
25
versionStr(key: string): string | null;
26
```
27

28
**Supported Version Keys:**
29

30
**Mobile/Browsers**: Mobile, Build, Version, VendorID, iPad, iPhone, iPod, Kindle, Chrome, Coast, Dolfin, Firefox, Fennec, Edge, IE, NetFront, NokiaBrowser, Opera, Opera Mini, Opera Mobi, UCBrowser, MQQBrowser, MicroMessenger, baiduboxapp, baidubrowser, SamsungBrowser, Iron, Safari, Skyfire, Tizen, Webkit, PaleMoon, SailfishBrowser, Gecko, Trident, Presto, Goanna
31

32
**Operating Systems**: iOS, Android, Sailfish, BlackBerry, BREW, Java, Windows Phone OS, Windows Phone, Windows CE, Windows NT, Symbian, webOS
33

34
**Usage Examples:**
35

36
```javascript
37
const MobileDetect = require('mobile-detect');
38

39
// Chrome version extraction
40
const chromeMd = new MobileDetect('Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36');
41
console.log(chromeMd.version('Chrome'));    // 91.0
42
console.log(chromeMd.versionStr('Chrome')); // '91.0.4472.124'
43

44
// iOS version
45
const iosMd = new MobileDetect('Mozilla/5.0 (iPhone; CPU iPhone OS 14_6 like Mac OS X)');
46
console.log(iosMd.version('iOS'));    // 14.6
47
console.log(iosMd.versionStr('iOS')); // '14_6'
48

49
// Android version
50
const androidMd = new MobileDetect('Mozilla/5.0 (Linux; Android 11; SM-G991B)');
51
console.log(androidMd.version('Android'));    // 11
52
console.log(androidMd.versionStr('Android')); // '11'
53

54
// WebKit version
55
console.log(chromeMd.version('Webkit'));    // 537.36
56
console.log(chromeMd.versionStr('Webkit')); // '537.36'
57

58
// Missing version
59
console.log(chromeMd.version('Firefox'));    // NaN
60
console.log(chromeMd.versionStr('Firefox')); // null
61
```
62

63
### Device Testing
64

65
Test for specific device types, operating systems, or browser characteristics.
66

67
```javascript { .api }
68
/**
69
 * Global test key against userAgent, os, phone, tablet and some other properties
70
 * @param key - The key (case-insensitive) to test for
71
 * @returns true when the key matches any detected property, false otherwise
72
 */
73
is(key: string): boolean;
74
```
75

76
**Testable Keys:**
77
- **Device Types**: All phone names (iPhone, Samsung, HTC, etc.), tablet names (iPad, Nexus, etc.)
78
- **Operating Systems**: iOS, Android, Windows, BlackBerry, etc.
79
- **Browsers**: Chrome, Firefox, Safari, Opera, Edge, IE, etc.
80
- **Special Categories**: Bot, MobileBot, DesktopMode, TV, WebKit, Console, Watch
81

82
**Usage Examples:**
83

84
```javascript
85
const md = new MobileDetect('Mozilla/5.0 (iPhone; CPU iPhone OS 14_6 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1.1 Mobile/15E148 Safari/604.1');
86

87
// Device testing
88
console.log(md.is('iPhone'));  // true
89
console.log(md.is('iPad'));    // false
90
console.log(md.is('Samsung')); // false
91

92
// OS testing  
93
console.log(md.is('iOS'));     // true
94
console.log(md.is('Android')); // false
95

96
// Browser testing
97
console.log(md.is('Safari'));  // true
98
console.log(md.is('Chrome'));  // false
99
console.log(md.is('WebKit'));  // true
100

101
// Special categories
102
console.log(md.is('Bot'));     // false
103
console.log(md.is('Mobile'));  // true (general mobile detection)
104

105
// Case insensitive
106
console.log(md.is('iphone'));  // true
107
console.log(md.is('SAFARI'));  // true
108
```
109

110
### Pattern Matching
111

112
Test User-Agent string against custom patterns using string or regex.
113

114
```javascript { .api }
115
/**
116
 * Do a quick test against navigator::userAgent
117
 * @param pattern - The pattern, either as String or RegExp (string converted to case-insensitive RegExp)
118
 * @returns true when the pattern matches, false otherwise
119
 */
120
match(pattern: string | RegExp): boolean;
121
```
122

123
**Usage Examples:**
124

125
```javascript
126
const md = new MobileDetect('Mozilla/5.0 (iPhone; CPU iPhone OS 14_6 like Mac OS X) AppleWebKit/605.1.15');
127

128
// String pattern (converted to case-insensitive regex)
129
console.log(md.match('iPhone'));           // true
130
console.log(md.match('android'));          // false
131
console.log(md.match('webkit'));           // true
132

133
// Multiple patterns with OR
134
console.log(md.match('iPhone|Android'));   // true
135
console.log(md.match('Android|Windows'));  // false
136

137
// Custom regex pattern
138
console.log(md.match(/iPhone/i));          // true
139
console.log(md.match(/OS \d+_\d+/));      // true (matches "OS 14_6")
140
console.log(md.match(/Chrome\/\d+/));     // false
141

142
// Gaming console detection
143
const consoleMd = new MobileDetect('Mozilla/5.0 (PlayStation 4 5.05)');
144
console.log(consoleMd.match('playstation|xbox|nintendo')); // true
145
```
146

147
### Mobile Grade Classification
148

149
Returns the mobile device capability grade (mostly historical, returns 'A' for modern devices).
150

151
```javascript { .api }
152
/**
153
 * Returns the mobile grade ('A', 'B', 'C')
154
 * @returns One of the mobile grades ('A', 'B', 'C')
155
 */
156
mobileGrade(): string;
157
```
158

159
**Grade Meanings:**
160
- **Grade A**: Full support (modern smartphones and tablets)
161
- **Grade B**: Enhanced support (older capable devices)  
162
- **Grade C**: Basic support (very old or limited devices)
163

164
**Usage Examples:**
165

166
```javascript
167
// Modern devices typically return 'A'
168
const modernMd = new MobileDetect('Mozilla/5.0 (iPhone; CPU iPhone OS 14_6 like Mac OS X)');
169
console.log(modernMd.mobileGrade()); // 'A'
170

171
const androidMd = new MobileDetect('Mozilla/5.0 (Linux; Android 11; SM-G991B)');
172
console.log(androidMd.mobileGrade()); // 'A'
173

174
// Older devices might return 'B' or 'C'
175
const oldMd = new MobileDetect('Mozilla/5.0 (SymbianOS/9.1; U; en-us) AppleWebKit/413');
176
console.log(oldMd.mobileGrade()); // 'B' or 'C'
177
```
178

179
### Static Properties and Methods
180

181
```javascript { .api }
182
/**
183
 * Library version string including version number and build date
184
 * Format: "<version> <build-date>"
185
 */
186
MobileDetect.version: string; // "1.4.5 2021-03-13"
187

188
/**
189
 * Static version of isPhoneSized method for current screen size detection
190
 * @param maxPhoneWidth - Maximum logical pixels to be considered as phone (default: 600)
191
 * @returns true if current screen width <= maxPhoneWidth, false otherwise,
192
 *          undefined in server-side environments (no window.screen access),
193
 *          undefined if maxPhoneWidth < 0
194
 */
195
static isPhoneSized(maxPhoneWidth?: number): boolean | undefined;
196

197
/**
198
 * Internal implementation object containing detection rules and methods
199
 * Warning: This is for extensibility/monkey-patching only. Methods and structure
200
 * may change between versions. Not recommended for production use.
201
 */
202
static _impl: MobileDetectImpl;
203
```
204

205
**Usage Examples:**
206

207
```javascript
208
// Library version
209
console.log(MobileDetect.version); // "1.4.5 2021-03-13"
210

211
// Static screen size testing (browser only)
212
console.log(MobileDetect.isPhoneSized(600)); // true/false/undefined
213
console.log(MobileDetect.isPhoneSized(480)); // true/false/undefined
214

215
// Server-side (always undefined)
216
console.log(MobileDetect.isPhoneSized()); // undefined
217
```
218

219
## Advanced Usage Patterns
220

221
### Comprehensive Device Analysis
222

223
```javascript
224
const md = new MobileDetect(navigator.userAgent);
225

226
// Complete device profile
227
const deviceProfile = {
228
  isMobile: !!md.mobile(),
229
  deviceType: md.phone() ? 'phone' : md.tablet() ? 'tablet' : 'desktop',
230
  manufacturer: md.mobile() || 'Unknown',
231
  os: md.os(),
232
  browser: md.userAgent(),
233
  browsers: md.userAgents(),
234
  grade: md.mobileGrade(),
235
  versions: {
236
    os: md.versionStr(md.os()),
237
    browser: md.versionStr(md.userAgent()),
238
    webkit: md.versionStr('Webkit')
239
  }
240
};
241

242
console.log(deviceProfile);
243
```
244

245
### Feature Detection Based on Capabilities
246

247
```javascript
248
const md = new MobileDetect(navigator.userAgent);
249

250
// Touch interface detection
251
const hasTouch = md.is('Mobile') || md.is('Tablet');
252

253
// High-DPI screen likely
254
const hasRetinaScreen = md.is('iPhone') || md.is('iPad') || 
255
  (md.is('Android') && md.version('Android') >= 4);
256

257
// WebKit-based optimizations
258
const isWebKit = md.userAgents().includes('Webkit');
259

260
// iOS-specific features
261
const supportsIOSFeatures = md.is('iOS') && md.version('iOS') >= 13;
262
```
263

264
### User Experience Optimization
265

266
```javascript
267
const md = new MobileDetect(navigator.userAgent);
268

269
// Responsive breakpoint logic
270
const isPhoneSized = md.isPhoneSized(768); // Custom phone threshold
271
const prefersMobile = md.is('Mobile') && isPhoneSized;
272

273
// Performance optimization
274
const isLowEndDevice = md.mobileGrade() === 'C' || 
275
  (md.is('Android') && md.version('Android') < 5);
276

277
// Browser-specific polyfills
278
const needsPolyfills = md.is('IE') || 
279
  (md.is('Android') && md.version('Android') < 4.4);
280
```
281

282
## Implementation Notes
283

284
- **Caching**: All methods cache results for performance on repeated calls
285
- **Case Sensitivity**: is() method is case-insensitive, match() respects regex flags
286
- **Version Parsing**: version() converts to number, versionStr() returns raw string
287
- **Pattern Updates**: Detection patterns require regular updates for new devices
288
- **Grade Accuracy**: mobileGrade() is largely outdated, most modern devices return 'A'