COBOL Tutorial

COBOL REPLACE Clause - Quick Reference

Progress0 of 0 lessons

Overview

The REPLACE clause is used in INSPECT statements to substitute characters in string data. It enables data transformation and cleaning by replacing specific characters with others while maintaining string structure.

Purpose and Usage

Character substitution - Replace characters with alternatives
Data transformation - Transform data formats and encodings
Data cleaning - Standardize character representations
Case conversion - Convert between upper and lowercase
Format standardization - Standardize data formats

REPLACE vs REMOVAL Concept

Original: "Hello World"

REPLACE ALL "o" BY "0": "Hell0 W0rld"

REMOVAL ALL "o": "Hell Wrld"

REPLACE maintains length, REMOVAL reduces length

REPLACE substitutes characters while maintaining string structure.

Syntax

The REPLACE clause follows specific syntax patterns within INSPECT statements and can be combined with various qualifiers.

Basic Syntax

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
* Basic REPLACE clause syntax
INSPECT data-name REPLACE ALL character BY character
 
* With different qualifiers
INSPECT data-name REPLACE LEADING character BY character
INSPECT data-name REPLACE FIRST character BY character
 
* Complete example
INSPECT TEXT-FIELD REPLACE ALL SPACES BY ZEROS
 
* With multiple characters
INSPECT TEXT-FIELD REPLACE ALL ".,;" BY SPACES
 
* With TALLYING
INSPECT TEXT-FIELD TALLYING counter FOR ALL character
    REPLACE ALL character BY replacement
 
* Combined with REMOVAL
INSPECT TEXT-FIELD 
    REPLACE ALL "A" BY "X"
    REMOVAL ALL SPACES

REPLACE can be used with ALL, LEADING, and FIRST qualifiers.

REPLACE vs REMOVAL Comparison

Aspect	REPLACE	REMOVAL
Action	Substitutes characters	Deletes characters
String length	Maintains length	Reduces length
Use case	Character transformation	Character elimination
Data integrity	Preserves structure	Changes structure
Performance	Similar	Similar

Qualifier Options

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
* ALL - Replace all occurrences
INSPECT TEXT-FIELD REPLACE ALL "A" BY "X"
 
* LEADING - Replace only leading occurrences
INSPECT TEXT-FIELD REPLACE LEADING SPACES BY ZEROS
 
* FIRST - Replace only the first occurrence
INSPECT TEXT-FIELD REPLACE FIRST "A" BY "X"
 
* Multiple characters
INSPECT TEXT-FIELD REPLACE ALL ".,;:!" BY SPACES
 
* Single character
INSPECT TEXT-FIELD REPLACE ALL "A" BY "X"
 
* Numeric characters
INSPECT TEXT-FIELD REPLACE ALL "9" BY "0"
 
* Alphabetic characters
INSPECT TEXT-FIELD REPLACE ALL "A" BY "X"

Different qualifiers control which characters are replaced.

Practical Examples

These examples demonstrate how to use the REPLACE clause effectively in different data transformation scenarios.

Case Conversion

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
IDENTIFICATION DIVISION.
PROGRAM-ID. CASE-CONVERTER.
 
DATA DIVISION.
WORKING-STORAGE SECTION.
01  TEXT-DATA           PIC X(50) VALUE "Hello World! This is a test.".
01  UPPERCASE-TEXT      PIC X(50).
01  LOWERCASE-TEXT      PIC X(50).
01  REPLACE-COUNT       PIC 9(2).
 
PROCEDURE DIVISION.
MAIN-PROCESS.
    * Convert to uppercase
    MOVE TEXT-DATA TO UPPERCASE-TEXT
    PERFORM CONVERT-TO-UPPERCASE
    
    * Convert to lowercase
    MOVE TEXT-DATA TO LOWERCASE-TEXT
    PERFORM CONVERT-TO-LOWERCASE
    
    * Display results
    DISPLAY "Original: " TEXT-DATA
    DISPLAY "Uppercase: " UPPERCASE-TEXT
    DISPLAY "Lowercase: " LOWERCASE-TEXT
    
    STOP RUN.
 
CONVERT-TO-UPPERCASE.
    * Replace lowercase letters with uppercase
    INSPECT UPPERCASE-TEXT REPLACE ALL "a" BY "A"
    INSPECT UPPERCASE-TEXT REPLACE ALL "b" BY "B"
    INSPECT UPPERCASE-TEXT REPLACE ALL "c" BY "C"
    INSPECT UPPERCASE-TEXT REPLACE ALL "d" BY "D"
    INSPECT UPPERCASE-TEXT REPLACE ALL "e" BY "E"
    INSPECT UPPERCASE-TEXT REPLACE ALL "f" BY "F"
    INSPECT UPPERCASE-TEXT REPLACE ALL "g" BY "G"
    INSPECT UPPERCASE-TEXT REPLACE ALL "h" BY "H"
    INSPECT UPPERCASE-TEXT REPLACE ALL "i" BY "I"
    INSPECT UPPERCASE-TEXT REPLACE ALL "j" BY "J"
    INSPECT UPPERCASE-TEXT REPLACE ALL "k" BY "K"
    INSPECT UPPERCASE-TEXT REPLACE ALL "l" BY "L"
    INSPECT UPPERCASE-TEXT REPLACE ALL "m" BY "M"
    INSPECT UPPERCASE-TEXT REPLACE ALL "n" BY "N"
    INSPECT UPPERCASE-TEXT REPLACE ALL "o" BY "O"
    INSPECT UPPERCASE-TEXT REPLACE ALL "p" BY "P"
    INSPECT UPPERCASE-TEXT REPLACE ALL "q" BY "Q"
    INSPECT UPPERCASE-TEXT REPLACE ALL "r" BY "R"
    INSPECT UPPERCASE-TEXT REPLACE ALL "s" BY "S"
    INSPECT UPPERCASE-TEXT REPLACE ALL "t" BY "T"
    INSPECT UPPERCASE-TEXT REPLACE ALL "u" BY "U"
    INSPECT UPPERCASE-TEXT REPLACE ALL "v" BY "V"
    INSPECT UPPERCASE-TEXT REPLACE ALL "w" BY "W"
    INSPECT UPPERCASE-TEXT REPLACE ALL "x" BY "X"
    INSPECT UPPERCASE-TEXT REPLACE ALL "y" BY "Y"
    INSPECT UPPERCASE-TEXT REPLACE ALL "z" BY "Z".
 
CONVERT-TO-LOWERCASE.
    * Replace uppercase letters with lowercase
    INSPECT LOWERCASE-TEXT REPLACE ALL "A" BY "a"
    INSPECT LOWERCASE-TEXT REPLACE ALL "B" BY "b"
    INSPECT LOWERCASE-TEXT REPLACE ALL "C" BY "c"
    INSPECT LOWERCASE-TEXT REPLACE ALL "D" BY "d"
    INSPECT LOWERCASE-TEXT REPLACE ALL "E" BY "e"
    INSPECT LOWERCASE-TEXT REPLACE ALL "F" BY "f"
    INSPECT LOWERCASE-TEXT REPLACE ALL "G" BY "g"
    INSPECT LOWERCASE-TEXT REPLACE ALL "H" BY "h"
    INSPECT LOWERCASE-TEXT REPLACE ALL "I" BY "i"
    INSPECT LOWERCASE-TEXT REPLACE ALL "J" BY "j"
    INSPECT LOWERCASE-TEXT REPLACE ALL "K" BY "k"
    INSPECT LOWERCASE-TEXT REPLACE ALL "L" BY "l"
    INSPECT LOWERCASE-TEXT REPLACE ALL "M" BY "m"
    INSPECT LOWERCASE-TEXT REPLACE ALL "N" BY "n"
    INSPECT LOWERCASE-TEXT REPLACE ALL "O" BY "o"
    INSPECT LOWERCASE-TEXT REPLACE ALL "P" BY "p"
    INSPECT LOWERCASE-TEXT REPLACE ALL "Q" BY "q"
    INSPECT LOWERCASE-TEXT REPLACE ALL "R" BY "r"
    INSPECT LOWERCASE-TEXT REPLACE ALL "S" BY "s"
    INSPECT LOWERCASE-TEXT REPLACE ALL "T" BY "t"
    INSPECT LOWERCASE-TEXT REPLACE ALL "U" BY "u"
    INSPECT LOWERCASE-TEXT REPLACE ALL "V" BY "v"
    INSPECT LOWERCASE-TEXT REPLACE ALL "W" BY "w"
    INSPECT LOWERCASE-TEXT REPLACE ALL "X" BY "x"
    INSPECT LOWERCASE-TEXT REPLACE ALL "Y" BY "y"
    INSPECT LOWERCASE-TEXT REPLACE ALL "Z" BY "z".

REPLACE is perfect for case conversion operations.

Data Format Standardization

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
* Standardize data formats using REPLACE
01  RAW-DATA            PIC X(100) VALUE "Product:ABC-123,Price:$99.99,Date:01/15/2023".
01  STANDARDIZED-DATA   PIC X(100).
01  REPLACE-STATS.
    05  DASHES-REPLACED  PIC 9(3).
    05  DOLLARS-REPLACED PIC 9(3).
 
PROCEDURE DIVISION.
STANDARDIZE-DATA.
    MOVE RAW-DATA TO STANDARDIZED-DATA
    
    * Replace dashes with underscores
    INSPECT STANDARDIZED-DATA 
        TALLYING DASHES-REPLACED FOR ALL "-"
        REPLACE ALL "-" BY "_"
    
    * Replace dollar signs with currency code
    INSPECT STANDARDIZED-DATA 
        TALLYING DOLLARS-REPLACED FOR ALL "$"
        REPLACE ALL "$" BY "USD"
    
    * Replace slashes with dashes in dates
    INSPECT STANDARDIZED-DATA REPLACE ALL "/" BY "-"
    
    * Replace colons with equals signs
    INSPECT STANDARDIZED-DATA REPLACE ALL ":" BY "="
    
    * Replace commas with semicolons
    INSPECT STANDARDIZED-DATA REPLACE ALL "," BY ";"
    
    DISPLAY "Original: " RAW-DATA
    DISPLAY "Standardized: " STANDARDIZED-DATA
    DISPLAY "Dashes replaced: " DASHES-REPLACED
    DISPLAY "Dollars replaced: " DOLLARS-REPLACED
 
* Alternative: Replace multiple characters at once
PROCEDURE DIVISION.
STANDARDIZE-ALT.
    MOVE RAW-DATA TO STANDARDIZED-DATA
    
    * Replace multiple punctuation marks
    INSPECT STANDARDIZED-DATA REPLACE ALL ".,;:" BY "|"
    
    * Replace multiple special characters
    INSPECT STANDARDIZED-DATA REPLACE ALL "-/_" BY "_"
    
    DISPLAY "Alternative: " STANDARDIZED-DATA.

REPLACE helps standardize data formats across different systems.

Data Cleaning and Validation

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
* Clean and validate data using REPLACE
01  DIRTY-DATA          PIC X(80) VALUE "  Product Name  ,  $99.99  ,  In Stock  ".
01  CLEANED-DATA        PIC X(80).
01  VALIDATION-COUNT    PIC 9(3).
 
PROCEDURE DIVISION.
CLEAN-DATA.
    MOVE DIRTY-DATA TO CLEANED-DATA
    
    * Replace multiple spaces with single spaces
    PERFORM UNTIL NO-MORE-DOUBLE-SPACES
        INSPECT CLEANED-DATA REPLACE ALL "  " BY " "
    END-PERFORM
    
    * Replace leading spaces with zeros
    INSPECT CLEANED-DATA REPLACE LEADING SPACES BY ZEROS
    
    * Replace trailing spaces with zeros
    INSPECT CLEANED-DATA 
        REPLACING CHARACTERS BY ZEROS
        BEFORE INITIAL " "
    
    * Replace invalid characters with valid ones
    INSPECT CLEANED-DATA REPLACE ALL "?" BY "X"
    INSPECT CLEANED-DATA REPLACE ALL "*" BY "X"
    INSPECT CLEANED-DATA REPLACE ALL "#" BY "X"
    
    * Count replacements for validation
    INSPECT CLEANED-DATA 
        TALLYING VALIDATION-COUNT FOR ALL "X"
    
    DISPLAY "Original: " DIRTY-DATA
    DISPLAY "Cleaned: " CLEANED-DATA
    DISPLAY "Invalid chars replaced: " VALIDATION-COUNT
 
* Check for double spaces
NO-MORE-DOUBLE-SPACES.
    IF CLEANED-DATA CONTAINS "  "
        MOVE "N" TO FLAG
    ELSE
        MOVE "Y" TO FLAG
    END-IF.

REPLACE is essential for data cleaning and validation processes.

Code Conversion and Transformation

cobol

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
* Convert between different code formats
01  OLD-CODE            PIC X(20) VALUE "ABC-123-XYZ".
01  NEW-CODE            PIC X(20).
01  CONVERSION-COUNT    PIC 9(2).
 
PROCEDURE DIVISION.
CONVERT-CODES.
    MOVE OLD-CODE TO NEW-CODE
    
    * Convert old product codes to new format
    INSPECT NEW-CODE REPLACE ALL "ABC" BY "PROD"
    INSPECT NEW-CODE REPLACE ALL "XYZ" BY "END"
    INSPECT NEW-CODE REPLACE ALL "-" BY "_"
    
    * Count conversions
    INSPECT NEW-CODE 
        TALLYING CONVERSION-COUNT FOR ALL "PROD"
    
    DISPLAY "Old code: " OLD-CODE
    DISPLAY "New code: " NEW-CODE
    DISPLAY "Conversions: " CONVERSION-COUNT
 
* Transform data between systems
PROCEDURE DIVISION.
TRANSFORM-DATA.
    MOVE OLD-CODE TO NEW-CODE
    
    * System A to System B conversion
    INSPECT NEW-CODE REPLACE ALL "A" BY "1"
    INSPECT NEW-CODE REPLACE ALL "B" BY "2"
    INSPECT NEW-CODE REPLACE ALL "C" BY "3"
    INSPECT NEW-CODE REPLACE ALL "X" BY "9"
    INSPECT NEW-CODE REPLACE ALL "Y" BY "8"
    INSPECT NEW-CODE REPLACE ALL "Z" BY "7"
    
    * Remove separators
    INSPECT NEW-CODE REPLACE ALL "-" BY SPACES
    
    DISPLAY "System A: " OLD-CODE
    DISPLAY "System B: " NEW-CODE.

REPLACE enables code conversion between different systems and formats.

Best Practices and Tips

Following these best practices ensures effective use of the REPLACE clause in COBOL applications.

REPLACE Best Practices

Use appropriate qualifiers - Choose ALL, LEADING, or FIRST based on needs
Combine related operations - Use multiple clauses in single INSPECT
Validate input data - Check data before applying REPLACE
Track replacement counts - Use TALLYING to monitor operations
Test with various inputs - Verify behavior with different data
Document character mappings - Clearly specify replacement rules

Common Pitfalls to Avoid

Pitfall	Problem	Solution
Incorrect character mapping	Data corruption	Verify replacement rules
Multiple INSPECT calls	Poor performance	Combine operations when possible
Not tracking replacements	Unknown data changes	Use TALLYING to count replacements
Incorrect qualifiers	Wrong characters replaced	Test with sample data
Field size issues	Data truncation	Ensure adequate field sizes

Performance Considerations

String length impact - Longer strings require more processing
Character frequency - More frequent characters increase processing time
Multiple REPLACE operations - Each INSPECT requires separate processing
Memory usage - String manipulation requires temporary storage
Compiler optimization - Some compilers optimize INSPECT operations

When to Use REPLACE vs REMOVAL

Scenario	Use REPLACE	Use REMOVAL
Character transformation	Yes	No
Character elimination	No	Yes
Maintain string length	Yes	No
Data cleaning	Yes	Yes
Format standardization	Yes	Sometimes

REPLACE Clause Quick Reference

Usage	Syntax	Example
Replace all occurrences	INSPECT field REPLACE ALL char BY char	INSPECT TEXT REPLACE ALL "A" BY "X"
Replace leading	INSPECT field REPLACE LEADING char BY char	INSPECT TEXT REPLACE LEADING SPACES BY ZEROS
Replace first	INSPECT field REPLACE FIRST char BY char	INSPECT TEXT REPLACE FIRST "A" BY "X"
With TALLYING	INSPECT field TALLYING counter REPLACE ALL char BY char	INSPECT TEXT TALLYING COUNT REPLACE ALL "A" BY "X"
Multiple characters	INSPECT field REPLACE ALL "chars" BY char	INSPECT TEXT REPLACE ALL ".,;" BY SPACES

Test Your Knowledge

1. What is the primary purpose of the REPLACE clause in COBOL?

To replace files
To substitute characters in strings
To replace records in files
To replace programs

2. In which statement is the REPLACE clause most commonly used?

MOVE
INSPECT
STRING
UNSTRING

3. What happens when a REPLACE clause is executed?

Characters are deleted from the string
Characters are substituted with other characters
Characters are moved to another field
Characters are counted

4. What is the relationship between REPLACE and REMOVAL in INSPECT statements?

They are the same thing
REPLACE substitutes, REMOVAL deletes
REPLACE is faster than REMOVAL
They cannot be used together

5. Which of the following is a valid REPLACE clause usage?

REPLACE ALL "A" BY "X"
REPLACE LEADING "A" BY "X"
REPLACE FIRST "A" BY "X"
All of the above

Frequently Asked Questions

Related Concepts

INSPECT Statement

Understanding the INSPECT statement for string manipulation.

REMOVAL Clause

Using REMOVAL clause for character deletion.

TALLYING Clause

Using TALLYING to count characters in INSPECT.

String Operations

Complete guide to string operations in COBOL.

Data Validation

Data validation techniques in COBOL.

REORG-CRITERIA Clause REPLACING Clause

COBOL Tutorial

COBOL REPLACE Clause - Quick Reference

Overview

Purpose and Usage

REPLACE vs REMOVAL Concept

Syntax

Basic Syntax

REPLACE vs REMOVAL Comparison

Qualifier Options

Practical Examples

Case Conversion

Data Format Standardization

Data Cleaning and Validation

Code Conversion and Transformation

Best Practices and Tips

REPLACE Best Practices

Common Pitfalls to Avoid

Performance Considerations

When to Use REPLACE vs REMOVAL

REPLACE Clause Quick Reference

Test Your Knowledge

Frequently Asked Questions

What is the difference between REPLACE and REMOVAL in INSPECT statements?

How does the REPLACE clause handle string length and character substitution?

Can you use REPLACE with all string data types in COBOL?

What are some common use cases for the REPLACE clause?

How do you handle errors and debugging when using the REPLACE clause?

Related Concepts

INSPECT Statement

REMOVAL Clause

TALLYING Clause

String Operations

Data Validation

Related Pages