0
# CODE128 Barcodes
1

2
CODE128 is a high-density linear barcode format that can encode the full ASCII character set. JsBarcode provides comprehensive CODE128 support with automatic mode switching for optimal encoding density and manual mode selection for specific requirements.
3

4
## Capabilities
5

6
### Automatic Mode Selection (CODE128AUTO)
7

8
The default CODE128 implementation automatically selects the optimal encoding mode (A, B, or C) based on the input data to minimize barcode length.
9

10
```javascript { .api }
11
/**
12
 * Generate CODE128 barcode with automatic mode selection
13
 * @param content - Data to encode (full ASCII support)
14
 * @returns Optimal CODE128 encoding
15
 */
16
JsBarcode(element, content, { format: "CODE128" });
17
// Also accepts: format: "CODE128AUTO"
18
```
19

20
**Usage Examples:**
21

22
```javascript
23
// Mixed alphanumeric - uses optimal mode switching
24
JsBarcode("#barcode", "Hello123World", { format: "CODE128" });
25

26
// Numeric data - automatically uses CODE128C for efficiency
27
JsBarcode("#barcode", "1234567890", { format: "CODE128" });
28

29
// Control characters - automatically handles with appropriate modes
30
JsBarcode("#barcode", "Data\x01\x02Test", { format: "CODE128" });
31
```
32

33
### CODE128-A Mode
34

35
CODE128-A encodes uppercase letters, digits, punctuation, control characters, and special characters. Suitable for data containing control characters or when uppercase-only encoding is required.
36

37
```javascript { .api }
38
/**
39
 * Generate CODE128-A barcode (uppercase, digits, control chars)
40
 * @param content - Data to encode (ASCII 0-95 + control chars)
41
 */
42
JsBarcode(element, content, { format: "CODE128A" });
43
```
44

45
**Character Set:** ASCII 0-95 (control characters, digits, uppercase letters, punctuation)
46

47
**Usage Examples:**
48

49
```javascript
50
// Uppercase letters and digits
51
JsBarcode("#barcode", "PRODUCT123", { format: "CODE128A" });
52

53
// With control characters
54
JsBarcode("#barcode", "DATA\x01\x02", { format: "CODE128A" });
55

56
// Punctuation and symbols
57
JsBarcode("#barcode", "ITEM-#123!", { format: "CODE128A" });
58
```
59

60
### CODE128-B Mode
61

62
CODE128-B encodes uppercase and lowercase letters, digits, and punctuation. Most commonly used mode for general alphanumeric data.
63

64
```javascript { .api }
65
/**
66
 * Generate CODE128-B barcode (mixed case alphanumeric)
67
 * @param content - Data to encode (ASCII 32-127)
68
 */
69
JsBarcode(element, content, { format: "CODE128B" });
70
```
71

72
**Character Set:** ASCII 32-127 (printable characters including lowercase)
73

74
**Usage Examples:**
75

76
```javascript
77
// Mixed case text
78
JsBarcode("#barcode", "Hello World!", { format: "CODE128B" });
79

80
// Alphanumeric with symbols
81
JsBarcode("#barcode", "Product-123@Company", { format: "CODE128B" });
82

83
// URLs or paths
84
JsBarcode("#barcode", "https://example.com/path", { format: "CODE128B" });
85
```
86

87
### CODE128-C Mode
88

89
CODE128-C encodes pairs of digits, making it highly efficient for purely numeric data. Each pair of digits is encoded as a single symbol.
90

91
```javascript { .api }
92
/**
93
 * Generate CODE128-C barcode (numeric pairs)
94
 * @param content - Numeric data to encode (even number of digits)
95
 */
96
JsBarcode(element, content, { format: "CODE128C" });
97
```
98

99
**Character Set:** Numeric digits 0-9 (encoded in pairs)
100

101
**Requirements:** Input must contain even number of digits
102

103
**Usage Examples:**
104

105
```javascript
106
// Even number of digits
107
JsBarcode("#barcode", "1234567890", { format: "CODE128C" });
108

109
// Product codes
110
JsBarcode("#barcode", "1234567890123456", { format: "CODE128C" });
111

112
// Serial numbers
113
JsBarcode("#barcode", "202501123456", { format: "CODE128C" });
114
```
115

116
## Advanced Features
117

118
### Function Codes and Special Characters
119

120
CODE128 supports special function codes for advanced applications:
121

122
```javascript
123
// FNC1 for GS1 applications (Application Identifier)
124
const gs1Data = String.fromCharCode(207) + "01123456789012345";
125
JsBarcode("#barcode", gs1Data, { format: "CODE128" });
126

127
// FNC2 for message append
128
const appendData = "DATA" + String.fromCharCode(202) + "MORE";
129
JsBarcode("#barcode", appendData, { format: "CODE128" });
130

131
// FNC3 for initialization
132
const initData = String.fromCharCode(201) + "INIT_DATA";
133
JsBarcode("#barcode", initData, { format: "CODE128" });
134
```
135

136
### Mode Switching
137

138
The automatic mode (CODE128AUTO) intelligently switches between modes within a single barcode:
139

140
```javascript
141
// Starts with letters (Mode B), switches to numbers (Mode C)
142
JsBarcode("#barcode", "ABC1234567890DEF", { format: "CODE128" });
143

144
// Complex data with optimal mode switching
145
JsBarcode("#barcode", "PART123\x01DATA456789", { format: "CODE128" });
146
```
147

148
### Validation and Error Handling
149

150
```javascript
151
// Valid ASCII characters for CODE128
152
const validData = "Valid ASCII text 123!@#";
153
JsBarcode("#barcode", validData, { 
154
  format: "CODE128",
155
  valid: function(isValid) {
156
    console.log("CODE128 validation:", isValid); // true
157
  }
158
});
159

160
// Invalid characters (outside ASCII range)
161
const invalidData = "Text with unicode: π ∑ ∆";
162
JsBarcode("#barcode", invalidData, { 
163
  format: "CODE128",
164
  valid: function(isValid) {
165
    if (!isValid) {
166
      console.log("Invalid characters for CODE128");
167
    }
168
  }
169
});
170
```
171

172
## Character Set Validation
173

174
### CODE128A Validation
175

176
```javascript { .api }
177
/**
178
 * Validates data for CODE128-A encoding
179
 * @param data - String to validate
180
 * @returns boolean - True if data contains only ASCII 0-95 + function codes
181
 */
182
// Internal validation regex: /^[\x00-\x5F\xC8-\xCF]+$/
183
```
184

185
### CODE128B Validation
186

187
```javascript { .api }
188
/**
189
 * Validates data for CODE128-B encoding  
190
 * @param data - String to validate
191
 * @returns boolean - True if data contains only ASCII 32-127 + function codes
192
 */
193
// Internal validation regex: /^[\x20-\x7F\xC8-\xCF]+$/
194
```
195

196
### CODE128C Validation
197

198
```javascript { .api }
199
/**
200
 * Validates data for CODE128-C encoding
201
 * @param data - String to validate  
202
 * @returns boolean - True if data contains even number of digits + FNC1
203
 */
204
// Internal validation regex: /^(\xCF*[0-9]{2}\xCF*)+$/
205
```
206

207
## Performance Considerations
208

209
- **CODE128C** is most efficient for purely numeric data (50% space reduction)
210
- **Automatic mode** provides optimal balance of density and compatibility
211
- **Caching** is available for repeated generation of identical barcodes
212
- **Manual mode selection** may be needed for legacy system compatibility
213

214
**Example Performance Comparison:**
215

216
```javascript
217
// Less efficient - forces CODE128B for numeric data
218
JsBarcode("#barcode1", "1234567890", { format: "CODE128B" });
219

220
// More efficient - uses CODE128C automatically  
221
JsBarcode("#barcode2", "1234567890", { format: "CODE128" });
222

223
// Most efficient - explicitly uses CODE128C
224
JsBarcode("#barcode3", "1234567890", { format: "CODE128C" });
225
```