Comparing strings is a fundamental task in programming, and Perl offers a variety of operators and techniques to accomplish this efficiently. This article, brought to you by COMPARE.EDU.VN, provides a detailed exploration of Perl string comparison, covering various operators, methods, and best practices for achieving accurate and optimized results. Whether you’re checking for equality, inequality, or performing more complex comparisons, understanding Perl’s string comparison capabilities is essential for effective scripting and data manipulation. Explore techniques like “eq”, “ne”, “cmp”, regular expressions, and case-insensitive comparisons.
1. Introduction to Perl String Comparison
String comparison is a cornerstone of many programming tasks, from validating user input to sorting data and searching for patterns. In Perl, strings are sequences of characters, and comparing them involves determining their relationship based on their character values. Perl provides several operators and functions to facilitate string comparison, each with its own nuances and use cases. Understanding these tools is crucial for writing robust and efficient Perl scripts. This is where COMPARE.EDU.VN comes in, providing clear comparisons to make the right choices.
1.1 Why String Comparison Matters
String comparison is essential for a multitude of reasons:
- Data Validation: Ensuring that user input matches expected formats or values.
- Sorting and Ordering: Arranging strings in alphabetical or custom order.
- Searching and Matching: Finding specific strings or patterns within larger texts.
- Conditional Logic: Controlling program flow based on string comparisons.
- Data Integrity: Verifying that data remains consistent and accurate.
Without effective string comparison techniques, applications would be prone to errors, inconsistencies, and security vulnerabilities.
1.2 Perl’s Approach to String Comparison
Perl distinguishes between numeric and string comparisons. When comparing strings, Perl uses a different set of operators than those used for numeric values. This distinction is important because Perl treats strings as sequences of characters, not as numbers. The primary operators for string comparison in Perl are:
eq: Equal tone: Not equal tolt: Less thangt: Greater thanle: Less than or equal toge: Greater than or equal tocmp: Comparison (returns -1, 0, or 1)
These operators perform comparisons based on the ASCII values of the characters in the strings.
1.3 The Importance of Choosing the Right Operator
Selecting the appropriate operator is crucial for achieving the desired outcome. Using the wrong operator can lead to unexpected results and logical errors in your code. For instance, using numeric comparison operators (==, !=, <, >, <=, >=) on strings will result in Perl attempting to convert the strings to numbers, which can lead to incorrect comparisons. Therefore, it’s vital to use the string comparison operators (eq, ne, lt, gt, le, ge, cmp) when working with strings.
2. Core String Comparison Operators in Perl
Perl offers a rich set of operators specifically designed for string comparison. These operators allow you to determine the relationship between two strings based on their character values. In this section, we’ll delve into the core string comparison operators, providing detailed explanations and examples of their usage.
2.1 The “eq” Operator: Checking for Equality
The eq operator is used to determine whether two strings are equal. It returns true if the strings are identical, character by character, and false otherwise.
2.1.1 Syntax and Usage
The syntax for using the eq operator is straightforward:
if ($string1 eq $string2) {
# Code to execute if $string1 is equal to $string2
}Here’s an example:
my $string1 = "hello";
my $string2 = "hello";
my $string3 = "world";
if ($string1 eq $string2) {
print "The strings '$string1' and '$string2' are equal.n";
} else {
print "The strings '$string1' and '$string2' are not equal.n";
}
if ($string1 eq $string3) {
print "The strings '$string1' and '$string3' are equal.n";
} else {
print "The strings '$string1' and '$string3' are not equal.n";
}Output:
The strings '$string1' and '$string2' are equal.
The strings '$string1' and '$string3' are not equal.2.1.2 Case Sensitivity
The eq operator is case-sensitive, meaning that it distinguishes between uppercase and lowercase letters. For example, “Hello” is not considered equal to “hello”.
my $string1 = "Hello";
my $string2 = "hello";
if ($string1 eq $string2) {
print "The strings '$string1' and '$string2' are equal.n";
} else {
print "The strings '$string1' and '$string2' are not equal.n";
}Output:
The strings '$string1' and '$string2' are not equal.To perform a case-insensitive comparison, you can convert both strings to the same case (either uppercase or lowercase) before using the eq operator. We’ll discuss case-insensitive comparisons in more detail later in this article.
2.2 The “ne” Operator: Checking for Inequality
The ne operator is the opposite of the eq operator. It returns true if two strings are not equal and false if they are identical.
2.2.1 Syntax and Usage
The syntax for using the ne operator is similar to that of the eq operator:
if ($string1 ne $string2) {
# Code to execute if $string1 is not equal to $string2
}Here’s an example:
my $string1 = "hello";
my $string2 = "hello";
my $string3 = "world";
if ($string1 ne $string2) {
print "The strings '$string1' and '$string2' are not equal.n";
} else {
print "The strings '$string1' and '$string2' are equal.n";
}
if ($string1 ne $string3) {
print "The strings '$string1' and '$string3' are not equal.n";
} else {
print "The strings '$string1' and '$string3' are equal.n";
}Output:
The strings '$string1' and '$string2' are equal.
The strings '$string1' and '$string3' are not equal.2.2.2 Case Sensitivity
Like the eq operator, the ne operator is case-sensitive. It distinguishes between uppercase and lowercase letters.
my $string1 = "Hello";
my $string2 = "hello";
if ($string1 ne $string2) {
print "The strings '$string1' and '$string2' are not equal.n";
} else {
print "The strings '$string1' and '$string2' are equal.n";
}Output:
The strings '$string1' and '$string2' are not equal.2.3 The “lt”, “gt”, “le”, and “ge” Operators: Comparing Order
The lt, gt, le, and ge operators are used to compare the order of two strings based on their ASCII values. These operators are similar to their numeric counterparts but operate on strings instead of numbers.
lt: Less thangt: Greater thanle: Less than or equal toge: Greater than or equal to
2.3.1 Syntax and Usage
The syntax for using these operators is consistent:
if ($string1 lt $string2) {
# Code to execute if $string1 is less than $string2
}
if ($string1 gt $string2) {
# Code to execute if $string1 is greater than $string2
}
if ($string1 le $string2) {
# Code to execute if $string1 is less than or equal to $string2
}
if ($string1 ge $string2) {
# Code to execute if $string1 is greater than or equal to $string2
}Here’s an example:
my $string1 = "apple";
my $string2 = "banana";
my $string3 = "apple";
if ($string1 lt $string2) {
print "'$string1' is less than '$string2'n";
}
if ($string1 gt $string2) {
print "'$string1' is greater than '$string2'n";
}
if ($string1 le $string3) {
print "'$string1' is less than or equal to '$string3'n";
}
if ($string2 ge $string3) {
print "'$string2' is greater than or equal to '$string3'n";
}Output:
'$string1' is less than '$string2'
'$string1' is less than or equal to '$string3'
'$string2' is greater than or equal to '$string3'2.3.2 Lexicographical Comparison
These operators perform lexicographical comparison, meaning that they compare strings character by character based on their ASCII values. The comparison stops as soon as a difference is found. For example, “apple” is less than “banana” because the ASCII value of ‘a’ (97) is less than the ASCII value of ‘b’ (98).
2.3.3 Case Sensitivity
Like the eq and ne operators, the lt, gt, le, and ge operators are case-sensitive. Uppercase letters have lower ASCII values than lowercase letters, so “Apple” is less than “apple”.
2.4 The “cmp” Operator: A Three-Way Comparison
The cmp operator provides a three-way comparison, returning -1, 0, or 1 depending on whether the first string is less than, equal to, or greater than the second string.
2.4.1 Syntax and Usage
The syntax for using the cmp operator is:
my $result = $string1 cmp $string2;The $result variable will contain:
- -1 if
$string1is less than$string2 - 0 if
$string1is equal to$string2 - 1 if
$string1is greater than$string2
Here’s an example:
my $string1 = "apple";
my $string2 = "banana";
my $string3 = "apple";
my $result1 = $string1 cmp $string2;
my $result2 = $string1 cmp $string3;
my $result3 = $string2 cmp $string1;
print "'$string1' cmp '$string2': $result1n";
print "'$string1' cmp '$string3': $result2n";
print "'$string2' cmp '$string1': $result3n";Output:
'$string1' cmp '$string2': -1
'$string1' cmp '$string3': 0
'$string2' cmp '$string1': 12.4.2 Use Cases
The cmp operator is particularly useful when you need to sort an array of strings. You can use it in conjunction with the sort function to define a custom sorting order.
my @strings = ("banana", "apple", "cherry");
my @sorted_strings = sort { $a cmp $b } @strings;
print "Sorted strings: @sorted_stringsn";Output:
Sorted strings: apple banana cherry2.4.3 Case Sensitivity
The cmp operator is case-sensitive, just like the other string comparison operators.
3. Beyond the Basics: Advanced String Comparison Techniques
While the core string comparison operators are sufficient for many tasks, Perl offers more advanced techniques for handling complex string comparison scenarios. In this section, we’ll explore some of these techniques, including case-insensitive comparisons, regular expressions, and using Smart::Match.
3.1 Case-Insensitive String Comparison
As we’ve seen, the core string comparison operators are case-sensitive. To perform case-insensitive comparisons, you need to convert both strings to the same case before comparing them. Perl provides the lc and uc functions for converting strings to lowercase and uppercase, respectively.
3.1.1 Using “lc” for Lowercase Conversion
The lc function converts a string to lowercase. You can use it to perform a case-insensitive comparison like this:
my $string1 = "Hello";
my $string2 = "hello";
if (lc($string1) eq lc($string2)) {
print "The strings '$string1' and '$string2' are equal (case-insensitive).n";
} else {
print "The strings '$string1' and '$string2' are not equal (case-insensitive).n";
}Output:
The strings '$string1' and '$string2' are equal (case-insensitive).3.1.2 Using “uc” for Uppercase Conversion
The uc function converts a string to uppercase. You can use it similarly:
my $string1 = "Hello";
my $string2 = "hello";
if (uc($string1) eq uc($string2)) {
print "The strings '$string1' and '$string2' are equal (case-insensitive).n";
} else {
print "The strings '$string1' and '$string2' are not equal (case-insensitive).n";
}Output:
The strings '$string1' and '$string2' are equal (case-insensitive).3.1.3 Choosing Between “lc” and “uc”
The choice between lc and uc is largely a matter of preference. Both functions achieve the same result for case-insensitive comparisons. However, lc is often preferred because it’s generally faster than uc.
3.2 String Comparison with Regular Expressions
Regular expressions provide a powerful way to perform complex string matching and comparison. Perl’s regular expression engine allows you to search for patterns within strings, validate string formats, and extract specific parts of strings.
3.2.1 Basic Regular Expression Matching
The =~ operator is used to test whether a string matches a regular expression.
my $string = "The quick brown fox jumps over the lazy dog";
if ($string =~ /fox/) {
print "The string contains the word 'fox'.n";
} else {
print "The string does not contain the word 'fox'.n";
}Output:
The string contains the word 'fox'.3.2.2 Case-Insensitive Regular Expression Matching
You can use the i modifier to perform a case-insensitive regular expression match.
my $string = "The quick Brown fox jumps over the lazy dog";
if ($string =~ /brown/i) {
print "The string contains the word 'brown' (case-insensitive).n";
} else {
print "The string does not contain the word 'brown' (case-insensitive).n";
}Output:
The string contains the word 'brown' (case-insensitive).3.2.3 Anchors and Boundaries
Regular expressions allow you to use anchors to match the beginning or end of a string. The ^ anchor matches the beginning of a string, and the $ anchor matches the end of a string.
my $string = "hello world";
if ($string =~ /^hello/) {
print "The string starts with 'hello'.n";
}
if ($string =~ /world$/) {
print "The string ends with 'world'.n";
}Output:
The string starts with 'hello'.
The string ends with 'world'.You can also use word boundaries (b) to match whole words.
my $string = "hello world";
if ($string =~ /bworldb/) {
print "The string contains the whole word 'world'.n";
}Output:
The string contains the whole word 'world'.3.2.4 Character Classes and Quantifiers
Regular expressions provide character classes to match sets of characters and quantifiers to specify how many times a character or group should be repeated.
d: Matches a digit (0-9)w: Matches a word character (a-z, A-Z, 0-9, _)s: Matches a whitespace character (space, tab, newline).: Matches any character (except newline)*: Matches zero or more times+: Matches one or more times?: Matches zero or one time{n}: Matches exactly n times{n,}: Matches n or more times{n,m}: Matches between n and m times
For example, to validate an email address:
my $email = "test@example.com";
if ($email =~ /^w+([.-]?w+)*@w+([.-]?w+)*(.w{2,3})+$/) {
print "The email address is valid.n";
} else {
print "The email address is invalid.n";
}Output:
The email address is valid.3.3 Using the “Smart::Match” Module
The Smart::Match module provides a more flexible and intuitive way to compare strings and other data types in Perl. It introduces the ~~ operator, which performs different types of comparisons depending on the data types of the operands.
3.3.1 Installing “Smart::Match”
To use Smart::Match, you need to install it from CPAN (Comprehensive Perl Archive Network). You can use the cpan command-line tool:
cpan Smart::Match3.3.2 Basic Usage of the “~~” Operator
The ~~ operator performs a smart match, which can handle different data types and comparison scenarios.
use Smart::Match;
my $string = "hello world";
if ($string ~~ "hello world") {
print "The strings are equal.n";
}Output:
The strings are equal.3.3.3 Smart Matching with Regular Expressions
The ~~ operator can also be used with regular expressions.
use Smart::Match;
my $string = "hello world";
if ($string ~~ /world/) {
print "The string contains the word 'world'.n";
}Output:
The string contains the word 'world'.3.3.4 Smart Matching with Arrays
The ~~ operator can be used to check if a value is present in an array.
use Smart::Match;
my @array = ("apple", "banana", "cherry");
if ("banana" ~~ @array) {
print "The array contains the value 'banana'.n";
}Output:
The array contains the value 'banana'.3.3.5 Benefits of Using “Smart::Match”
The Smart::Match module simplifies complex comparison scenarios and makes your code more readable. It automatically handles different data types and comparison methods, reducing the need for explicit type checking and conversion.
4. Performance Considerations for Perl String Compare
While Perl’s string comparison operators are generally efficient, there are situations where performance can become a concern, especially when dealing with large strings or performing a large number of comparisons. In this section, we’ll discuss some performance considerations and optimization techniques for string comparison in Perl.
4.1 The Impact of String Length
The length of the strings being compared can significantly impact performance. Comparing very long strings requires more time and resources than comparing short strings. If you’re working with large strings, consider these strategies:
-
Short-Circuiting: If you only need to check if two strings are different, compare their lengths first. If the lengths are different, the strings cannot be equal, and you can avoid a character-by-character comparison.
my $string1 = "long string 1"; my $string2 = "long string 2"; if (length($string1) != length($string2)) { print "The strings are not equal.n"; } else { if ($string1 eq $string2) { print "The strings are equal.n"; } else { print "The strings are not equal.n"; } } -
Hashing: For equality comparisons, consider using a hashing algorithm to generate a unique hash value for each string. You can then compare the hash values instead of the strings themselves. This can be faster than a character-by-character comparison, especially for long strings.
use Digest::MD5 qw(md5_hex); my $string1 = "long string 1"; my $string2 = "long string 2"; my $hash1 = md5_hex($string1); my $hash2 = md5_hex($string2); if ($hash1 eq $hash2) { print "The strings are equal.n"; } else { print "The strings are not equal.n"; }Note that hashing is only suitable for equality comparisons and not for ordering comparisons.
4.2 Regular Expression Performance
Regular expressions can be powerful, but they can also be computationally expensive. Complex regular expressions can take a long time to execute, especially on large strings. Here are some tips for optimizing regular expression performance:
-
Specificity: Use specific patterns instead of generic ones. For example,
d{3}-d{2}-d{4}is more specific thand+-d+-d+for matching a US Social Security number. -
Anchors: Use anchors (
^and$) to limit the search to the beginning or end of the string. This can significantly reduce the search space. -
Character Classes: Use character classes (
d,w,s) instead of individual characters when possible. Character classes are often faster than individual character matches. -
Quantifiers: Be careful with quantifiers (
*,+,?,{n,m}). Greedy quantifiers (*and+) can backtrack and try multiple matches, which can be slow. Consider using non-greedy quantifiers (*?and+?) if appropriate. -
Pre-Compilation: If you’re using the same regular expression multiple times, pre-compile it using the
qr//operator. This can improve performance by avoiding the overhead of compiling the regular expression each time it’s used.my $regex = qr/pattern/; foreach my $string (@strings) { if ($string =~ $regex) { # Code to execute if the string matches the pattern } }
4.3 Avoiding Unnecessary Comparisons
Sometimes, you can avoid unnecessary string comparisons by carefully structuring your code. For example, if you’re comparing a string against multiple possible values, consider using a hash lookup instead of a series of if statements.
my %values = (
"value1" => 1,
"value2" => 2,
"value3" => 3,
);
my $string = "value2";
if (exists $values{$string}) {
print "The string is a valid value.n";
my $value = $values{$string};
print "The value is $value.n";
} else {
print "The string is not a valid value.n";
}This can be faster than:
my $string = "value2";
if ($string eq "value1") {
print "The string is value1.n";
} elsif ($string eq "value2") {
print "The string is value2.n";
} elsif ($string eq "value3") {
print "The string is value3.n";
} else {
print "The string is not a valid value.n";
}4.4 Profiling and Benchmarking
The best way to identify performance bottlenecks in your code is to profile and benchmark it. Perl provides several tools for profiling and benchmarking, including the Devel::DProf module and the Benchmark module.
-
Devel::DProf: This module allows you to profile your code and identify the parts that are taking the most time.
perl -d:DProf your_script.pl dprofpp -
Benchmark: This module allows you to measure the execution time of different code snippets and compare their performance.
use Benchmark qw(:all); cmpthese(100000, { 'eq' => sub { my $result = "string1" eq "string2"; }, 'ne' => sub { my $result = "string1" ne "string2"; }, });
By profiling and benchmarking your code, you can identify the areas where string comparison is impacting performance and apply the appropriate optimization techniques.
5. Best Practices for Perl String Compare
To write robust, maintainable, and efficient Perl code, it’s essential to follow best practices for string comparison. In this section, we’ll outline some key best practices to keep in mind.
5.1 Always Use String Comparison Operators for Strings
This may seem obvious, but it’s worth emphasizing: always use the string comparison operators (eq, ne, lt, gt, le, ge, cmp) when comparing strings. Do not use the numeric comparison operators (==, !=, <, >, <=, >=) on strings. Using the wrong operators can lead to unexpected results and logical errors.
5.2 Be Mindful of Case Sensitivity
Remember that the core string comparison operators are case-sensitive. If you need to perform a case-insensitive comparison, use the lc or uc function to convert both strings to the same case before comparing them.
5.3 Consider Unicode and Encoding
Perl supports Unicode, but you need to be aware of encoding issues when working with Unicode strings. Ensure that your strings are encoded correctly and that you’re using the appropriate functions for handling Unicode characters. The utf8 pragma can be helpful for working with UTF-8 encoded strings.
use utf8;
use Encode;
my $string1 = "你好"; # Chinese characters
my $string2 = decode_utf8("你好");
if ($string1 eq $string2) {
print "The strings are equal.n";
} else {
print "The strings are not equal.n";
}5.4 Use Regular Expressions Wisely
Regular expressions are powerful, but they can also be complex and computationally expensive. Use regular expressions wisely and optimize them for performance. Avoid overly complex regular expressions and pre-compile them if you’re using them multiple times.
5.5 Document Your Code
As with any code, it’s important to document your string comparison logic. Explain the purpose of the comparison, the expected input, and the possible outcomes. This will make your code easier to understand and maintain.
5.6 Test Your Code Thoroughly
Test your string comparison logic thoroughly to ensure that it’s working correctly. Test with different inputs, including edge cases and invalid data. Use unit tests to automate the testing process and ensure that your code remains correct as you make changes.
6. Real-World Examples of Perl String Comparison
To illustrate the practical applications of Perl string comparison, let’s look at some real-world examples.
6.1 Validating User Input
String comparison is commonly used to validate user input in web applications and command-line tools. For example, you might want to check if a user has entered a valid email address or a strong password.
sub validate_email {
my ($email) = @_;
if ($email =~ /^w+([.-]?w+)*@w+([.-]?w+)*(.w{2,3})+$/) {
return 1; # Valid email
} else {
return 0; # Invalid email
}
}
my $email = "test@example.com";
if (validate_email($email)) {
print "The email address is valid.n";
} else {
print "The email address is invalid.n";
}sub validate_password {
my ($password) = @_;
if (length($password) < 8) {
return 0; # Password too short
}
if ($password !~ /[a-z]/) {
return 0; # Password must contain a lowercase letter
}
if ($password !~ /[A-Z]/) {
return 0; # Password must contain an uppercase letter
}
if ($password !~ /d/) {
return 0; # Password must contain a digit
}
return 1; # Valid password
}
my $password = "P@sswOrd123";
if (validate_password($password)) {
print "The password is valid.n";
} else {
print "The password is invalid.n";
}6.2 Sorting Data
String comparison is used to sort data in alphabetical or custom order. For example, you might want to sort a list of names or a list of files.
my @names = ("Charlie", "Alice", "Bob");
my @sorted_names = sort { $a cmp $b } @names;
print "Sorted names: @sorted_namesn";my @files = ("file10.txt", "file2.txt", "file1.txt");
my @sorted_files = sort {
my ($num_a) = $a =~ /file(d+).txt/;
my ($num_b) = $b =~ /file(d+).txt/;
$num_a <=> $num_b;
} @files;
print "Sorted files: @sorted_filesn";6.3 Searching and Matching
String comparison is used to search for specific strings or patterns within larger texts. For example, you might want to find all occurrences of a particular word in a document or extract specific data from a log file.
my $text = "The quick brown fox jumps over the lazy dog. The fox is brown.";
while ($text =~ /bfoxb/g) {
print "Found 'fox' at position ", pos($text) - length("fox"), "n";
}my $log_line = "2023-10-27 10:00:00 [INFO] User logged in: JohnDoe";
if ($log_line =~ /[INFO] User logged in: (w+)/) {
my $username = $1;
print "User logged in: $usernamen";
}6.4 Data Transformation
String comparison can be combined with other string manipulation techniques to transform data from one format to another.
my $date = "2023-10-27";
if ($date =~ /(d{4})-(d{2})-(d{2})/) {
my ($year, $month, $day) = ($1, $2, $3);
my $formatted_date = "$month/$day/$year";
print "Formatted date: $formatted_daten";
}7. Conclusion: Mastering Perl String Comparison
String comparison is a fundamental skill for any Perl programmer. By understanding the various operators, techniques, and best practices, you can write robust, efficient, and maintainable code that effectively handles string data. Whether you’re validating user input, sorting data, searching for patterns, or transforming data, mastering Perl string comparison will empower you to solve a wide range of programming challenges.
Remember to choose the right operator for the task, be mindful of case sensitivity and encoding issues, use regular expressions wisely, document your code, and test it thoroughly. With these principles in mind, you’ll be well-equipped to tackle any string comparison task that comes your way. COMPARE.EDU.VN hopes this article has clarified string comparisons in Perl.
8. Call to Action
Ready to make smarter decisions? Visit COMPARE.EDU.VN today to explore comprehensive comparisons and expert insights. Whether you’re choosing a product, service, or educational path, we’re here to help you compare your options and make the best choice.
Address: 333 Comparison Plaza, Choice City, CA 90210, United States
Whatsapp: +1 (626) 555-9090
Website: compare.edu.vn
9. FAQ: Perl String Comparison
9.1 What is the difference between “eq” and “==” in Perl?
eq is used for string comparison (equal to), while == is used for numeric comparison. Using == on strings will attempt to convert them to numbers, which can lead to incorrect results.
9.2 How can I perform a case-insensitive string comparison in Perl?
Use the lc or uc function to convert both strings to the same case before comparing them with eq or ne.
9.3 How can I check if a string contains a specific substring?
Use the =~ operator with a regular expression. For example: if ($string =~ /substring/).
9.4 How can I sort an array of strings in Perl?
Use the sort function with the cmp operator to define the sorting order. For example: @sorted_array = sort { $a cmp $b } @array;.
9.5 How can I compare strings based on their length?
Use the length function to get the length of each string and then compare the lengths using numeric comparison operators.
9.6 Are regular expressions always the most efficient way to compare strings in Perl?
No, regular expressions can be computationally expensive. For simple equality or inequality checks, the eq and ne operators are generally more efficient.
9.7 How can I validate if a string is a valid email address in Perl?
Use a regular expression that matches the email address format. There are many regular expressions available online for this purpose.
9.8 What is the “Smart::Match” module in Perl?
The Smart::Match module provides a more flexible and intuitive way to compare strings and other data types in Perl. It introduces the ~~ operator, which performs different types of comparisons depending on the data types of the operands.
9.9 How can I make sure my Perl code handles Unicode characters correctly?
Use the utf8 pragma and the `Encode
