Stringis in the E-Commerce Enablers Industry

String

string

In our last post, we introduced you to the project and how it offers a revolutionary set of language extensions for Java, including the ability to parse and process files seamlessly in Java. Today, we will take a look at another exciting feature of the Manifold project: string templates. Manifold JSON https://www.youtube.com/watch?v=ite6a5y50yQ&embedable=true But before we get to that, some of the feedback I got from the previous post was that I was unclear about Manifold. Manifold is a combination of an IDE plugin and plugins to Maven or Gradle. Once used we can enhance the Java language (or environment) almost seamlessly in a fluid way. A frequent question was how is it different from something like ? Lombok There are many similarities and in fact, if you understand Lombok then you are on your way to understand Manifold. Lombok is a great solution for some problems in the Java language. It is a bandaid on the verbosity of Java and some of its odd limitations (I mean bandaid as a compliment, no hate mail). Manifold differs from Lombok in several critical ways: It’s modular - all the extensions built into Manifold are separate from one another. You can activate a particular feature or leave it out of the compiler toolchain. It’s bigger - Lombok has many features but Manifold's scope is fantastic and far more ambitious. It tries to do the “right thing” - Lombok is odd. We declare private fields but then use getters and setters as if they aren’t private. Manifold uses properties (which we will discuss later) that more closely resemble what the Java language “should have offered”. Manifold also has some drawbacks: It only works as a compiler toolchain and only in one way. Lombok can be compiled back to plain Java source code and removed. It only supports one IDE - IntelliJ. These partially relate to the age of Manifold which is a new project by comparison. But it also relates to the different focus. Manifold focuses on language functionality and a single working fluid result. JEP 430 String Interpolation One of the big features coming to JDK 21 is , which is a string interpolation language change. JEP 430 It will allow writing code like this: String name = "Joan";
String info = STR."My name is \{name}"; In this case, will have the value . This is just the tip of the iceberg in this JSR as the entire architecture is pluggable. I will discuss this in a future video but for now, the basic functionality we see here is pretty fantastic. info “My name is Joan” Unfortunately, it will take years to use this in production. It will be in preview in JDK 21, then it will be approved. We will wait for an LTS, and then wait for the LTS to reach critical mass. In the meantime, can we use something as nice as this today? Maven Dependencies Before we dive into the code, I want to remind you that all the code for this and other videos in this series is available on (feel free to star it and follow). GitHub String templating has no dependencies. We still need to make changes to the pom file but we don’t need to add dependencies. I’m adding one dependency here for the advanced templates we will discuss soon. All that’s needed is the compiler plugin. That means that string templates are a compile-time feature and have no runtime impact! <dependencies>
   <dependency>
       <groupId>systems.manifold</groupId>
       <artifactId>manifold-templates-rt</artifactId>
       <version>${manifold.version}</version>
   </dependency>
</dependencies>

<build>
   <plugins>
       <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-compiler-plugin</artifactId>
           <version>3.8.0</version>
           <configuration>
               <source>19</source>
               <target>19</target>
               <encoding>UTF-8</encoding>
               <compilerArgs>
                   
                   <arg>-Xplugin:Manifold</arg>
               </compilerArgs>

               
               <annotationProcessorPaths>
                   <path>
                       <groupId>systems.manifold</groupId>
                       <artifactId>manifold-strings</artifactId>
                       <version>${manifold.version}</version>
                   </path>
                   <path>
                       <groupId>systems.manifold</groupId>
                       <artifactId>manifold-templates</artifactId>
                       <version>${manifold.version}</version>
                   </path>
               </annotationProcessorPaths>
           </configuration>
       </plugin>
   </plugins>
</build> Manifold String Interpolation To begin, we can create a new variable that we can use to get external input. In the second line, we integrate that variable into the printout: String world = args.length > 0 ? args[0] : "world";
System.out.println("Hello $world! I can write \$world as the variable..."); The backslash syntax implicitly disables the templating behavior, just like in other string elements in Java. This will print . “Hello world! I can write $world as the variable…” There’s something that you can’t really see in the code, you need to look at a screenshot of the same code: ![]( align="center") https://cdn.hashnode.com/res/hashnode/image/upload/v1683029461078/84f52be2-30c3-435f-bbf6-4a53937b3859.png It’s subtle, do you see it? Notice the expression, it is colored differently. It's no longer just a string but a variable embedded in a string. This means that we can control-click it and go to the variable declaration, rename it, or see find its usage. $world There's another way to escape a string, and we can use the annotation on a method or a class to disable this functionality in the respective block of code. @DisableStringLiteralTemplates This can be useful if we use the dollar sign frequently in a block of code: @DisableStringLiteralTemplates
private static void noTemplate(String word) {
   System.out.println("Hello $world!");
} Templates The Manifold project allows us to create JSP-like templates without all of the baggage. We can define a base class to a template to create generic code for the templates and place common functionality in a single location. We can create a file called HelloTemplate.html.mtl in the resources/templates directory with the following content. Notice the params we define in the template file can be anything: <%@ params(String title, String body) %>
<!DOCTYPE html>
<html lang="en">
<head>
 <meta charset="UTF-8">
 <title>${title}</title>
</head>
<body>
   ${body}
</body>
</html> This will seem very familiar to those of us with a JSP background. We can then use the file in the Java code like this, we can pass the parameters and they will replace the appropriate blocks in the HTML file: System.out.println(HelloTemplate.render("My Title", "My Body")); Notice the generated template it compiled to a class, similar to JSP. Unlike JSP this template isn’t a servlet and can be used in any context. A local application, a server, etc. The templating language is more lightweight and doesn’t depend on various server APIs. It is also less mature. The main value is in using such an API to generate arbitrary files like Java source files or configuration files. The templating capabilities are powerful yet simple. Just like we could in JSP, we can embed Java source code into the template e.g. we can include control flow and similar restrictions just like we could in JSP: <% if(body != null) {%>
   ${body}
<% } %> Why Not: JSP, Velocity, Thymeleaf, or Freemarker? There are so many templating languages in Java already… Adding yet another one seems like a heavy burden of replication. I think all of those are great and this isn’t meant to replace them, at least not yet. Their focus is very much on web generation, they might not be ideal for more fluid use cases like code generation or web frameworks like Spark. Another big advantage is size and performance. All of these frameworks have many dependencies and a lot of runtime overhead. Even JSP performs the initial compilation in runtime by default. This templating support is compiled and Spartan, in a good way. It’s fast, simple, and deeply integrated into the application flow. Import We can import Java packages just like we can in every Java class using code like this: <%@ import com.debugagent.stringtemplates.* %> Once imported we can use any class within the code. Notice that this import statement must come above other lines in the code, just like a regular import statement. Include We can use include to simply include another template into the current template, allowing us to assemble sophisticated templates like headers and footers. If we want to generate a complex Java class, we can wrap the boilerplate in a generic template and include that in. We can conditionally include a template using an if statement and use a for loop to include multiple entries: <%@ include JavaCode("ClassName", classBody) %> Notice that we can include an entry with parameters and pass them along to the underlying template. We can pass hardcoded strings or variables along the included chain. A Lot More I skipped extends because of a documentation issue, which has since been fixed. it has a lot of potential. There’s layout functionality that has a lot of potentials but is missing parameter passing at the moment. But the main value is in the simplicity and total integration. When I define a dependency on a class and remove it from the code the error appears even in the template file. This doesn’t happen in Thymeleaf. Final Word In conclusion, with the Manifold project, we can write fluent text processing code today without waiting for a future JVM enhancement. The introduction of String templates can help Java developers generate files that aren't a web application, which is useful in several cases e.g. where code generation is needed. Manifold allows us to create JSP-like templates without all of the baggage and generate any arbitrary file we want. With the inclusion of sophisticated options like layout, the sky's the limit. There’s a lot more to Manifold and we will dig deeper into it as we move forward. Also published here.

The Manifold Project: Exploring String Templates for Java Development

In this article, we will learn to remove commas from strings using the Python program. We will create a program using different methods and using different functions. Table of Contents Using replace() function Remove n number of comma from the strings using replace() function Using regex() function Conclusion 1. Remove Commas Using Replace() Function We will use replace the () function to remove all commas from the string. What Is Replace() Function? replace() is an in-built function in Python, where replace() function is used to replace any characters from the given strings or is used to replace all occurrences of a substring from another substring. So, using replace() function, we replace commas with blank; this can give strings that have no commas. string = I a,m ,A,nk,ur Input I am Ankur Output Explanation First, we will take the input of strings from the user using the input() in-built function (input() function takes a string as an input in Python). Now, we will create a new variable named new_string. In this variable, we will use replace() function. replace() function takes two parameters, the first parameter contains substrings that we want to remove from the strings, and another parameter contains another substring for replacing the first parameter in strings. Lastly, we will print the new_string. Program 1 # take input of string from user
string = input("Enter strings to remove commas: ")

# use replace() function
new_string = string.replace(",", "")

# print new_string
print(new_string) Enter strings to remove commas: I a,m ,A,nk,ur
I am Ankur Output 2. Remove n Number of Commas From the Given Strings Using the remove() function If we have to remove a specific number of commas from a given string, then we also do that using replace() in-built function of Python. replace() function is also used to remove a specific number of substrings from a given string in Python programming. Explanation First, we will take the input of strings and n from the user using the input() in-built function of Python. n is the number of commas that we have to remove from the strings. Now, we will create a new variable named new_string. In this variable, we will use replace() function. replace() function takes 3 parameters, the first parameter contains substrings that we want to remove from the strings, the second parameter contains another substring for replacing the first parameter in strings, and the last parameter is options used to remove a specific number of substrings from the given strings. Lastly, print the new_string. Program # take input of string from user and n 
string = input("Enter strings to remove commas: ")
n = int(input("How many commas do you want to remove from the string: "))

# use replace() function
new_string = string.replace(",", "",n)

# print new_string
print(new_string) Enter strings to remove commas: I, a,m An,kur Output How many commas do you want to remove from the string: 2 I am An,kur How to Remove the First Comma From the Strings? We will remove the first comma from the string using replace() function. Remember what we said about replace() function taking 3 parameters. Explanation First, we will take the input of strings from the user using the input() in-built function of Python. Now, we will create a new variable named new_string. In this variable, we will use replace() function. Lastly, print the new_string. Program # take input of string from user 
string = input("Enter strings to remove commas: ")

# use replace() function
new_string = string.replace(",", "",1)

# print new_string
print(new_string) Enter strings to remove commas: I a,m Ankur
I am Ankur Output 3. Remove Commas Using the regex() package We will use the regex() package to remove all commas from the strings in the Python program. regex(), or re, is a Python package that contains a sub() function, which helps us remove commas from the given strings. re.sub() function helps to replace commas with blank. Explanation First, we will import the re package using import. Then, we will take the input of the string using the input() in-built function (The input function used to take strings input from the user). Then, we will create a variable named new_string that uses the re.sub() function to remove all commas. re.sub() function takes 3 arguments. The first argument takes substrings that we want to remove from the strings, the second argument takes another substring for replacing the first substring in strings, and the last argument takes the name of the string, which we want to remove all commas from it. Then lastly, print the new_string. Program # import re package
import re

# take input of string from user 
string = input("Enter strings to remove commas: ")

# use re.sub|() function
new_string = re.sub(",", "", string)

# print new_string
print(new_string) Enter strings to remove commas: I, a,m An,kur
I am Ankur Output Conclusion In this article, we show multiple methods to remove commas from the strings. We use two methods for it, replace() and regex package, both methods are easy to implement in the program. We also see how to remove the n number of commas from the strings using replace function in Python programming with examples and explanation. Also published here Photo by on Steve Johnson Unsplash

How to Remove Commas From String Python

Why bytes(str).length is not enough for getting the length of a string in Solidity, and understanding the strlen method from contracts of ens. In the world of Javascript finding the length of a string is such an easy thing. Just do and that’s all 🤌 str.length But strings are not so friendly to work with, in ❗. In solidity, the string is a group of characters stored inside an array and stores the data in bytes. Solidity There is no length method in string type. I was going through Buildspace’s project and found the link to . I knew to find the length of the string in Solidity we can convert the string into bytes and find its length. So it should have been as easy as doing 🤌 but the method in this util file was a bit different: build-polygon-ens StringUtils.sol bytes(str).length; // SPDX-License-Identifier: MIT
// Source:
// https://github.com/ensdomains/ens-contracts/blob/master/contracts/ethregistrar/StringUtils.sol
pragma solidity >=0.8.4;

library StringUtils {
    /**
     * @dev Returns the length of a given string
     *
     * @param s The string to measure the length of
     * @return The length of the input string
     */
    function strlen(string memory s) internal pure returns (uint256) {
        uint256 len;
        uint256 i = 0;
        uint256 bytelength = bytes(s).length;

        for (len = 0; i < bytelength; len++) {
            bytes1 b = bytes(s)[i];
            if (b < 0x80) {
                i += 1;
            } else if (b < 0xE0) {
                i += 2;
            } else if (b < 0xF0) {
                i += 3;
            } else if (b < 0xF8) {
                i += 4;
            } else if (b < 0xFC) {
                i += 5;
            } else {
                i += 6;
            }
        }
        return len;
    }
} It had this weird ‘for’ loop in code which I couldn’t understand. So, the developer in me googled it 🕵️‍♀️, but all the articles I came across did this to find the length of the string I found some similar code on Stackoverflow but no one actually explained what is happening inside. bytes(str).length; for(len = 0; i < bytelength; len++) {
            bytes1 b = bytes(s)[i];
            if(b < 0x80) {
                i += 1;
            } else if (b < 0xE0) {
                i += 2;
            } else if (b < 0xF0) {
                i += 3;
            } else if (b < 0xF8) {
                i += 4;
            } else if (b < 0xFC) {
                i += 5;
            } else {
                i += 6;
            }
  } After 3 hours of 🐌 self-exploration I was able to figure it out myself (a little slow but I did it 🍾), So I thought let’s write it down so it would be helpful for all the folks like me (not so experienced with bits, bytes 0️⃣1️⃣). Let’s try to Unblock/Decode this How bytes(str).length works When we convert string to bytes this is what Solidity does: // if we do bytes("xyz"), solidity converts it as 
xyz -> 78 79 7a // 78=x, 79=y, 7a=z
ABC -> 41 42 43 // 41=A, 42=B, 43=C Use this for converting strings to bytes website If you see each character generates 1 byte that’s why when we do bytes(””).length we get the length of the string. But there are some characters for which generated bytes are more than one. For example: € -> e2 82 ac For the symbol of the Euro, generated bytes are 3. So if we try to find the length of string which includes the symbol of Euro( ) 🤑 in it, the length returned by will not return the correct string length for this character as there are 3 bytes generated: € bytes(str).length € That’s when that ‘for’ loop we've seen above comes to the rescue ⛑️ Let’s iterate over this e2 82 ac bytes array and check what’s happening inside that loop: for(len = 0; i < bytelength; len++) {
            bytes1 b = bytes(s)[i];
                        // b = e2 for first iteration
            if(b < 0x80) {
                i += 1;
            } else if (b < 0xE0) {
                i += 2;
            } else if (b < 0xF0) {
                i += 3;
            } else if (b < 0xF8) {
                i += 4;
            } else if (b < 0xFC) {
                i += 5;
            } else {
                i += 6;
            }
  } For the first iteration there is a condition on the following line b=e2 if(b < 0x80) {
     i += 1;
} Let's decode this. This condition will basically compare decimal values of these hexadecimal characters: 0x80 -> 128
// our b is e2 at the moment, decimal value for e2 = 226
0xe2 -> 226 For regular characters, decimal conversion of their hex character will be , like for it is 97. < 128 a So, if we check all conditions like this for(len = 0; i < bytelength; len++) {
            bytes1 b = bytes(s)[i];
            if(b < 0x80) { //0x80 = 128 => 226 < 128 ❌
                i += 1;
            } else if (b < 0xE0) { //0xE0 = 224 => 226 < 224 ❌
                i += 2;
            } else if (b < 0xF0) { //0xF0 = 240 => 226 < 240 ✅
                i += 3;
            } 
                        ...
  } So, if our the condition in ‘for’ loop will be , which is false and the loop will break, and the value of at the moment. i is 3 3<3 len will be 1 And that’s it, it is the correct value for the length of string “ ” € If you want to try some more strings like “ ”, here is a small list of characters that occupies more than 1 byte: € € -> e2 82 ac 
Ã -> c3 83
¢ -> c2 a2 Create, a random string anything like , for example, and try it out. abc¢Ã Ta-Da 🎉, and now it works Connect with me on : Twitter or @pateldeep_eth LinkedIn My DMs are open to any kind of improvement or suggestions Originally published . here

Find the Length of Any String in Solidity 

To be, or not to be (empty), that is the question... That's a simple, yet complex, question. First of all, when a string is not empty? For me, when there is at least one character or one number. Do it from scratch Let's create a custom function to achieve this functionality. { } ( ) public static bool IsStringEmpty myString string // do something Ok, now we have to think of how to check if the string myString is empty. Of course, the string must be not null. And must not be empty. Maybe... its length must be greater than zero? { myString== || myString == String.Empty || myString.Length == ;
} ( ) public static bool IsStringEmpty myString string return null 0 Ok, we should be fine. But, what if the string contains only whitespaces? I mean, the string " ", passed to the method, will return true. IsStringEmpty If that's not what we want, we should include this check on the method. Of course, this implies a bit of complexity to check null values. { myString== || myString == String.Empty || myString.Length == || myString.Trim().Length == ;
} ( ) public static bool IsStringEmpty myString string return null 0 0 Ok, we covered the most important scenarios. So we can try the method with our values: System; System.Collections.Generic; { { arr = List() { , , , String.Empty, }; ( txt arr)
        {
            Console.WriteLine( + IsStringEmpty(txt));
        }
    } { (myString == ) ;
        myString = myString.Trim(); myString == String.Empty || myString.Length == ;
    }
} using using public class Program ( ) public static void Main var new "1" null "   " "hello" foreach string in "IsStringEmpty? " ( ) public static bool IsStringEmpty myString string if null return true return 0 will return IsStringEmpty? False
IsStringEmpty? True
IsStringEmpty? True
IsStringEmpty? True
IsStringEmpty? False Fine. Too tricky, isn't it? And we just reinvented the wheel. .NET native methods: String.IsNullOrEmpty and String.IsNullOrWhitespace C# provides two methods to achieve this result, and , with a subtle difference. String.IsNullOrEmpty String.IsNullOrWhiteSpace String.IsNullOrEmpty checks only if , so it doesn't recognize strings composed by empty characters. the string passed as parameter has at least one symbol String.IsNullOrWhitespace covers the scenario described in this post. It checks . both empty characters and for escape characters str1 = ;
Console.WriteLine(String.IsNullOrEmpty(str1)); Console.WriteLine(String.IsNullOrWhiteSpace(str1)); str2 = ;
Console.WriteLine(String.IsNullOrEmpty(str2)); Console.WriteLine(String.IsNullOrWhiteSpace(str2)); str3 = ;
Console.WriteLine(String.IsNullOrEmpty(str3)); Console.WriteLine(String.IsNullOrWhiteSpace(str3)); str4 = ;
Console.WriteLine(String.IsNullOrEmpty(str4)); Console.WriteLine(String.IsNullOrWhiteSpace(str4)); str5 = ;
Console.WriteLine(String.IsNullOrEmpty(str5)); Console.WriteLine(String.IsNullOrWhiteSpace(str5)); string "hello" //False //False string null //True //True string "" //True //True string "\n   \t   " //False //True string "       " //False //True You can see a live example . here Wrapping up As you can see, out of the box .NET provides easy methods to handle your strings. You shouldn't reinvent the wheel when everything is already done. Also published on Code4it .

How to check if a string is REALLY empty with C#

Every developer needs to know how to work with strings in the language they are using. The Go libraries makes replacing parts of strings easy for a developer. I will show three solutions for replacing parts of a string in Go. Solution 1 The simple way is to use the function from the package. This function takes in four values: Replace strings : This is the reference string. s : This is the value in the string we want to change. old : This is the new string value. new string : This is the number of times to do the replacement. n If you use -1 it will replace all string values that are equal to the old value <a href="https://medium.com/media/43d9351ad089b4470f014a0ae8bd5466/href">https://medium.com/media/43d9351ad089b4470f014a0ae8bd5466/href</a> This is the output: Mary had a little Gopher Gopher duck If we change line 13 above to: out := strings.Replace(refString, "duck", "dog", -1) This is the output: Mary had a little Gopher Gopher Gopher Solution 2 When you have more than one string value to replace you should use the function from the packages. This function returns a . This method can be use to replace multiple string a once. NewReplacer strings new Replacer from a list of old, new string pairs <a href="https://medium.com/media/d6abfd854b89c827ad40411162c62836/href">https://medium.com/media/d6abfd854b89c827ad40411162c62836/href</a> This is the output: John had a little Gopher Gopher Solution 3 The more sophisticated way of replaces substring is to use regular expression or regex. For this solution, we will use the and from the package. MustCompile ReplaceAllString regexp : Creates our regular expression. In this case, it’s a string that starts with d and is followed by any characters between a and z. MustCompile : This will replace substring that matches the regular expression the string Gopher ReplaceAllStrings <a href="https://medium.com/media/e44a348cecd264aeebdd47a502bdb947/href">https://medium.com/media/e44a348cecd264aeebdd47a502bdb947/href</a> This would output: Mary had a little Gropher Gopher Originally published at harrisonbrock.com .

Replacing Parts of a String

Photo by on Mr Cup / Fabien Barral Unsplash ‘String’ is a sequence of characters. Considering you as a programmer (why else on earth would you read this article dedicated to programmers?), there is a high probability that you already know this definition. And I think, it is fair to assume that you already used ‘String’ in at least one programming language. Despite that, I should remind you one more time, ‘String’ in programming world has nothing to do with the which popularizes more than any physicist ever did or could do. ‘String Theory’ Sheldon Cooper In this article, I’m going to introduce you to some very important concepts/terms related to String which you might need to use in your day to day programming. Also, familiarity with these terms might help you in your job interview one day, who knows? Though some of the terms have a little complex meaning from ‘Linguistic’ aspect, I’ll try to avoid them and explain it from the view programmers need to understand. Another thing needs to be mentioned that, I’m not going to show any code examples or how you can do string operations in your favorite languages. I’ll just talk about the terms and concepts and your job is to find out how to use them when you need them. Makes sense? Ok, let’s go. Character Encoding: The primary component of a String is ‘Character’, wait, you already know that. But do you know that basically characters are just code representations? I mean, the computer doesn’t know characters, letters etc. or store them as such in memory. The computer stores them as numbers (as binary, to be precise). There are some conventions that define which number will represent which character. This character sets basically maps some numbers or code points to textual characters. Then at the time of visual representation, computers read them from memory and represent them as characters based on that mapping. This mapping and character representation is what they call ‘Character Encoding’. The following article did a pretty darn good job explaining everything about it. So, I’m suggesting you read that to gain a better understanding of ‘Character Encoding’. _This article is about encodings and character sets. An article by Joel Spolsky entitled The Absolute Minimum Every…_kunststube.net What Every Programmer Absolutely, Positively Needs to Know About Encodings and Character Sets to… Most of the novice programmers (especially who started their programming with C-like languages) fairly assumes that all of the characters in the world are single byte and obviously ASCII characters. I’m not gonna blame them, because I was one of them too once. But now I know that it’s not true and there is a vast world of Unicode characters out in the wild and as a programmer you need to deal with them pretty frequently. So, the first thing you need to remember that, All the characters in the world aren’t created equal and they are always not single byte characters. Most of the Unicode characters can be stored as a 16 bit or 2-byte data type. But still, there are some which can’t. There are , where 2 bytes can store as many as around 65,536 characters. So, Multi-byte data types are needed to store the remainders. So, you should keep in mind that: more than 136,000 code points defined in Unicode Some programming languages (C, C++ etc.) provide single byte data type ( ) for specifically ASCII characters and multi-byte data type ( ) for Unicode. char wchar_t Some programming languages (Java etc.) have only multi-byte data types for character types. The days of is long gone, and you need to keep that in mind vividly. one byte == one character Let’s give you another tiny bit of information while we are at it. Character encoding can be fixed length or variable length. You might’ve heard encoding schemes like UTF-8, UTF-16, UTF-32 etc. There are various other encodings though, but let’s just have a brief understanding of these three of Unicode Character Encoding. UTF-16 represents most of the commonly used Unicode code points in a single 16-bit character type and uses two 16-bit characters to represent the remainder. That means UTF-16 is a variable length encoding using minimum 16-bits (2 bytes) and maximum 32-bits (4 bytes). UTF-8 uses one to four 8-bit characters to encode all Unicode code points. It’s also another variable length encoding which represents basically the ASCII characters using a single byte (that’s handy because it means ASCII text is also valid in UTF-8) and rest of the code points by 2, 3, 4 bytes as needed. UTF-32 uses 4 bytes for all characters. It is a fixed length encoding. Your knowledge about character encoding might come in handy when you’ll work with . Also, you can guess from that this knowledge is very important in some other aspects like how much space, memory your text will consume based on it’s encoding. internationalization and localization this single discussion thread All I’m saying is, just be careful about character encoding when you are dealing with String or Text. String Immutability: Most of the languages provide ‘String’ as a basic data type. The thing you need to know about the language you are working with is, whether the String data type of your language is or . For instance, Java and Python String types are Immutable. If you try to treat an immutable String as mutable it will throw an error and you might wonder: Mutable Immutable What’s wrong with this String? You might be a little curious to know why Strings are Immutable in some languages, right? Let’s explore it a little. You see, in languages like C, they store Strings as an array of characters and acts like general purpose arrays. So, as you can easily mutate an array, you can mutate the String too. On the other hand, Languages like Java and Python treats String as Object and they When the compiler sees a String literal, it looks for the String in the pool. If a match is found, the reference to the new literal is directed to the existing String and no new String object is created. The existing String simply has one more reference. Here comes the point of making String objects immutable: set aside a special area of memory called the “String constant pool”. In the String constant pool, a String object is likely to have one or many references. If several references point to same String without even knowing it, it would be bad if one of the references modified that String value. That’s why String objects are immutable. So, the thing to learn from here is, be sure about the Immutability of Strings in your favorite languages before work with them. Ladies and gentleman, It’s time to learn some terms. Substring: Substring of a string S, is a string which occurs in S. Let’s say it more clearly. Any sequential part of a string is it’s substring. So, ‘is nice’ is a substring of the string ‘This is nice’. But ‘nice is’ not, because ‘nice is’ can’t be found as it is in the string ‘This is nice’. You must find the substring as it is in the String. The list of all substrings of the string “ ” would be: “ ”, “ ”, “ ”, “ ”, “ ”, “ ”, “ ”, “ ”, “ ”, “ ”, “ ”, “ ”, “ ”, “ ”, “”. apple apple appl pple app ppl ple ap pp pl le a p l e Prefix: A prefix of a string S is a substring of S that occurs at the of S.This might be clear from an example. The list of all prefixes of the string “ ” would be: “ ”, “ ”, “ ”, “ ”, “ beginning apple apple appl app ap a” So, to be a prefix, a substring needs to be started from the beginning of that string. A of a string is not equal to the string itself. So, “apple” won’t be a proper prefix of “apple”. proper prefix Suffix: A suffix of a string S is a substring of S that occurs at the of S.The list of all substrings of the string “ ” would be: “ ”, “ ”, “ ”, “ ”, “ ” end apple apple pple ple le e So, to be a suffix, a substring needs to be ended at the end of that string. A of a string is not equal to the string itself. So, “apple” won’t be a proper suffix of “apple”. proper suffix Subsequence: The formal definition of a subsequence is: “a subsequence is a sequence that can be derived from another sequence by deleting some or no elements without changing the order of the remaining elements.” Let me explain it in simple words. A string is a sequence of characters, right? So, if we pick some characters maintaining the same sequence appeared in the original String then the resulting string would be a subsequence of the original string. Let’s say we have a string “Hello”. Then the “eo” is a subsequence of that string. But “ol” won’t be a subsequence, because it didn’t appear in the same sequence in “Hello”. The list of all subsequences for the word “ ” would be: “ ”. apple e, l, le, p, pe, pl, ple, p, pe, pl, ple, pp, ppe, ppl, pple, a, ae, al, ale, ap, ape, apl, aple, ap, ape, apl, aple, app, appe, appl, apple Dude, did you get the difference between ‘substring’ and ‘subsequence’? Let’s learn some common operations about Strings. Concatenation: This means concatenating two or more strings together.Let’s say there are two strings: and . The concatenation result of these two strings results in another string . ‘Hello ’ ‘World’ ‘Hello World’ Capitalization/Case Folding: This means converting all the characters of a string to same Case, either ‘LowerCase’ or ‘UpperCase’. Capitalization has various use cases. One of them is: If you need to make a comparison between two Strings in manner, you always need to normalize both texts to either ‘LowerCase’ or ‘UpperCase’. Well, to be honest, it won’t always be that simple. You’d face some weird cases if your strings contain Non-Latin characters. Let’s say your string is “résumé". To convert strings to UpperCase, you would generally convert the [a-z] characters set to [A-Z] characters set. So, what would be the UpperCase of ? In that case, you need to make some other considerations like Unicode Normalization and such. Learn more about it . Case insensitive é here Join: Though it seems from the name that ‘Join’ is similar to ‘Concatenation’, but there is a subtle but important difference between them. Unlike ‘Concatenation’, ‘Join’ concatenates the strings using a given ‘separator’ or ‘glue’ between each of the string element. So, if a list of strings given like: along with a separator/glue , then the resulting string will be: . In some cases, the separator can be an empty string(‘’), where it will behave exactly like ‘Concatenation’. [‘Hello’, ‘world’, ‘again’] ‘-’ ‘Hello-world-again’ Split/Tokenize: Splitting or Tokenizing a string means to break down a single string to several parts based on a delimiter or set of delimiters. Let’s say you have a String: Now, if you tokenize this string based on whitespace, you’ll end up with a list of strings or tokens: . Notice that, the delimiter won’t be included in the resulting strings. Also, in some cases, you might need to tokenize a string based on a pattern instead of some specific delimiters. This can be done easily by . ‘Why so serious?’ [‘Why’, ‘so’, ‘serious?’] Regex Trim/Strip: Trimming/Stripping a string generally means removing leading and trailing whitespaces from a string. Whitespace in this context is all the whitespace characters (space, tab, no-break space, etc.) and all the . So, a given string: ‘ this is simple ’ would be ‘this is simple’ after trimming/stripping. Variants of Trimming/Stripping includes: line terminator characters (LF, CR, etc.) trimming/stripping only leading(left trimming) or trailing(right trimming) whitespaces. any sequence of whitespace characters within the string is replaced with a single space, which is also known as ‘Space normalization’. Lexicographic Ordering: Sometimes you need to define an ordering for a list of strings. Most popular ordering is , which is also known as ‘Alphabetic order’ or ‘Dictionary order’. You’ve seen how words are ordered in a Dictionary, right? That’s exactly what lexicographic ordering is. So, if you order the list of words in lexicographical order, it would be: ‘Lexicographic Order’ [‘ant’, ‘Zebra’, ‘apple’, ‘applecart’] Zebraantappleapplecart Note that, in lexicographical ordering, UpperCase letters come before Lowercase letters, that’s why ‘Zebra’ comes before ‘ant’. Also, longer strings come after the same prefixed smaller strings, that’s why ‘apple’ precedes ‘applecart’. String Searching/Comparison: You’d very often do a lot of tasks which is directly or indirectly associated with some sort of string searching and/or comparison. Let’s talk about some common types of String/Pattern matching. The most common of them will be to check exact match between two strings. Which you would fairly assume to do by == operator. But I want to give a simple tip which might save you one day from a lot of trouble. If you store two strings in two variables and try to check their equality by == operator you need to make sure if your programming language is doing value match or just reference match? If your programming language treats String as Object then most likely when you try to check two String Object by == operator, . On the other hand, other programming languages might just check the value equality of these two string variables. So, keep that in mind. it would check equality of the reference of the two Object, instead of their values You’ve seen ‘autocomplete’ or ‘autosuggestion’ features in google search or your phones contact search, right? If you observe this closely you would see that they are doing basically some prefix match. Your typed string vs the list of strings they already stored. So, how would you do it by yourself if needed? If your list of strings is not large, you can take any naive approach to match with all of them. But it won’t be that much efficient for large lists. The efficient approach would be to use some sophisticated data structure like . Details discussion about it is beyond the scope of this article, so you should dive deep into it on your own. Trie Similarly, if you need to do some suffix match, you can convert the problem to a prefix match problem by storing reverse of the strings along with the actual strings or you can take help of . Suffix Tree Sometimes you need to do some pattern matching like, check if a string is a substring of a given string or if a pattern can be found in the given string. In that cases, you need to take help from various and choose the one which fulfills your need. String searching algorithms In some cases, When we are running a search, we want to find relevant results not only for the exact expression we typed on the search bar, but also for the other possible forms of the words we used. For example, it’s very likely we will want to see results containing the form if we have typed in the search bar. This can be achieved through two possible methods: . The aim of both processes is the same: Though this term is most popular in , it is also used in full-text search mechanism in some database system and text search engines like . “ran”, “running” “run” stemming and lemmatization reducing the inflectional forms of each word into a common base or root. NLP ElasticSearch The last thing I want to mention here is the ‘Phonetic String Matching’. Phonetic algorithms basically index words based on their pronunciation. So, if you want to match two words by their pronunciation you’d need to use Phonetic algorithms. Most common uses of Phonetic algorithms are ‘Spell checking’, ‘Searching’ etc. There are several phonetic algorithms available to do the job like , etc. But be aware that most of the phonetic algorithms were developed for the English language. So, they might not work for other languages as you expect. soundex metaphone Phew! That’s a whole lot to digest at once. Does it seem like that I dumped a lot of information without explaining them in details? Yeah, that’s exactly what I did. Because my primary focus on this article was to make you familiar with the buzzwords of String/Text processing. If you at least know the terms you can explore it deeply when necessary. So, that’s all for today. Leave your positive/negative feedback in the comments. Just don’t be too harsh, cause that’ll hurt my ego. Bye bye then. :)

What every programmer should know about ‘String’

In this tutorial, we'll dive into resolving the error in Python. This error often occurs when you try to use a string object where a bytes object is expected. We'll go through various examples and explanations to help you understand and fix this error. TypeError: a bytes-like object is required, not 'str' Understanding the Difference between Strings and Bytes Before we dive into examples, it's crucial to understand the difference between strings and bytes in Python. Strings A string is a enclosed in quotes (single, double, or triple). In Python, strings are Unicode by default, meaning they can represent a wide range of characters from different languages and scripts. sequence of characters string_example = "Hello, World!" Bytes A bytes object is a sequence of bytes, which are integer values ranging from 0 to 255. They are used to represent or as a way to handle encoded text. Bytes objects are immutable and are created using the constructor or the prefix before the quotes. raw binary data bytes() b bytes_example = b"Hello, World!" Resolving TypeError: a bytes-like object is required, not 'str' in Python We will use a problem-and-solution approach to resolve the error. By examining different scenarios where this error may occur, we will first identify the root cause of the problem and then apply the appropriate solution to fix it. Through this method, we aim to provide you with a comprehensive understanding of the issue, which will enable you to effectively tackle similar errors in your Python code. TypeError: a bytes-like object is required, not 'str' Example 1: Reading a File as Bytes One common scenario where this error occurs is when you try to read a file as . bytes but accidentally read it as a string Problematic Code with open("example.txt", "r") as file:
    content = file.read()
    print(content) Explanation In this example, the file is opened in text mode ("r") which means the content will be read as a string. If the file contains non-text data or you want to process it as bytes, the error may occur. Solution To resolve this error, you should open the file in binary mode ("rb") instead of text mode. This will ensure that the content is read as bytes. with open("example.txt", "rb") as file:
    content = file.read()
    print(content) Example 2: Using the Library socket Another common scenario where this is when using the library. This library requires bytes objects for sending and receiving data. error occurs socket Problematic Code import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('example.com', 80))

request = "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"
sock.send(request) Output Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: a bytes-like object is required, not 'str' Explanation In this example, we create a and try to send a request to a server. The method expects a bytes object, but we pass a string instead, causing the error. socket object send() Solution To resolve this error, convert the string to bytes using the method, which will as bytes using the specified encoding (default is UTF-8). encode() encode the string import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('example.com', 80))

request = "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"
sock.send(request.encode()) Example 3: Writing Bytes to a File Another scenario where this error might occur is when trying to write bytes to a file but accidentally writing a string. Problematic Code data = "Hello, World!"

with open("output.txt", "wb") as file:
    file.write(data) Explanation In this example, the file is opened in binary mode ("wb"), expecting bytes as input. However, we pass a string to the method, resulting in the error. write() Solution To resolve this error, convert the string to bytes using the method before writing it to the file. encode() data = "Hello, World!"

with open("output.txt", "wb") as file:
    file.write(data.encode()) Conclusion In conclusion, this article provided an in-depth tutorial on resolving the error in Python. By understanding the difference between strings and bytes, and using a problem-and-solution approach, we demonstrated how to effectively identify and address the root cause of this error in various scenarios. TypeError: a bytes-like object is required, not 'str' FAQs on TypeError: a bytes-like object is required, not 'str' in Python 1. How can I convert a string to bytes in Python? To convert a string to bytes, use the method, which encodes the string as bytes using the specified encoding (default is UTF-8). encode() 2. How can I convert bytes to a string in Python? To convert bytes to a string, use the method, which decodes the bytes object into a string using the specified encoding (default is UTF-8). decode() 3. When should I use strings, and when should I use bytes in Python? Use strings when working with human-readable text and characters, like processing sentences, words, or any Unicode characters. Use bytes when dealing with raw binary data, encoded text, or when interfacing with APIs or libraries that require bytes input/output, like file I/O or sockets.

Resolving TypeError: A Bytes-like Object is Required, Not 'str' in Python

Character Encoding Demystified: Everything you Need to Know About ASCII, Unicode, UTF-8

In python, a String is a sequence of characters that may contain special characters or alphanumeric characters, for example, ". It is possible to access sub-parts of the string commonly known as a python substring. "we meet on Friday at 08:00 am You can also define substring as a sequence of characters within a string. From the previous example, python substrings can be "Friday", "at", "meet", and others. Python provides different ways and methods to generate a substring, check if a substring is present, index of a substring, and more. You can extract a substring from a string by slicing with indices that obtain your substring as follows: string[start:stop:step] - The starting index of the substring. start - The ending index of a substring. stop - A number specifying the step of the slicing. The default value is 1. step Indices can be positive or negative numbers. The positive indices start from the beginning to the end of the string and the negative indices start from the end to the beginning of a string. In this article, you will learn various operations related to substrings in . python 1. Get the first n characters from the string This example will show you how to slice the first 5 characters from the string. string = print(string[: ]) "hello world" 5 Here you define the stop index which is 5. The start index is by default is 0. Output: ‘hello’ 2.Get the middle characters from the string via python substrings This example will show you how to slice characters from index 3 to index 5 from the string. string = print(string[ : ]) "hello world" 3 5 Output: 'lo’ 3.Get the last character from the string To get the last character use the -1 index (negative index). Check the following example. string = print(string[ ]) "hacker noon" -1 Output: ‘n’ 4.Get the last n characters from the string In this example, you will slice the last 4 characters from the string. Here you use the negative index to start slicing from the end of the string. string = print(string[ :]) "hackernoon" -4 Output: ‘noon’ 5.Slice the string with steps via python substrings You can slice the string with steps after indicating start-index and stop-index. By default, the step is 1 but in the following example, the step size is 2. string = print(string[:: ]) "welcome to hackernoon" 2 Output: ‘wloet akron’ 6.Validate if a substring is present within a string Sometimes you want to check if a substring present in a string. The following example will validate if a substring ‘noon’ is in a  string. substring = string = print(substring string) "noon" "welcome to hackernoon" in If present, it will return True otherwise False. Output: True 7.Alternative way to check if the python substring is present in a string You can use the find() method to check if a substring present in a string. Let’s check the following example. substring = string = print(string.find(substring)) "zz" "hello world" If available it returns the left-most index of the substring otherwise return -1 means not available. Output: -1 This means is not present in “hello world”. “zz” 8.Get the character of a given index. You can choose to slice a specific character according to its index number. string = print(string[ ]) "hello world" 4 Output: ‘O’ 9. Create a list of substrings from a string in python You can use the method to create a list of substrings. Let’s check the following example. split() string = print(string.split()) "welcome to hackernoon platform" Output: ['welcome', 'to', 'hackernoon', 'platform'] 10.Reverse the string with negative steps To reverse the string, the step must be a negative value. Example -1. string = print(string[:: ]) "welcome to hackernoon" -1 Output: ‘noonrekcah ot emoclew’ 11.Count substring occurrence in the string You can use the count() method to know how many times a particular substring presented in a string. string = print(string.count( )) "we will have a quick introduction to hackernoon this afternoon" 'noon' Output: 2 Final Thoughts on Python Substrings Congratulations 👏👏, you have made it to the end of this article! I hope you have learned something new about python substring. If you learned something new or enjoyed reading this article, please share it so that others can see it. Until then, see you in the next post! You can also find me on Twitter . @Davis_McDavid And you can read more articles like this . here Want to keep up to date with all the latest in python? Subscribe to our newsletter in the footer below!

Python Substrings: Everything You Need to Know

Introduction We all look for a to get faster where we want to go, shortcut Who has never quickly flip through some pages of a book or even go straight to the last chapter? Although this may seem like a good idea at the beginning, I’ve already shared in several blog posts multiple reasons why a gradual improvement is much better and more productive than going straight to fun things. The truth is, if you want to code for several years and do not burn out in the first years or even months of a career as a web developer you have to study the basics, I tell you a secret,  even when, after years of experience, when you believe that there is nothing you do not know about a basic topic, pick up the first book or one of the first articles you read, you will always find a paragraph that you did not pay attention to or a concept that you did not fully understand before. This post, in fact, is for everyone. As beginners, they are just starting their journey with to expert programmers who will discover features of the code they did not know. PHP Even on a basic topic like what we’re going to see below, Here, in fact, there is general and detailed information on variables in PHP. I’ll give you some helpful insight on what are and how to declare and use variables in the best way for your web applications. This post is part of the series “PHP basics for expert programmers” click on the links below for other posts published so far. PHP basics for expert web developers Construct and Comments of PHP 7 When writing a program, whether it is a simple to-do list or an integrated payment system for a bank that has clients worldwide you are going to need to use variables. Variables are used to store data. Think of variables as if they were boxes. In every language, a “box” has a name written on the outside which is the name by which the box is called and a “thing” inside. programming As said every box (variable) has a name, when we give a name to the box and define what is inside it we say that we assign a value to a variable. There are different types of “things” that a box can have inside, the variables are in fact divided into three main categories: scalar type variables, composite variables and resources. The scalars are the most basic and easy to understand. They are divided into: Boolean Integer Float Strings The composites ones are a bit more complicated but nothing impossible, they are: Arrays Objects Callables Iterables Then we have , which can be seen simply as, for example, objects external to PHP as files, database connections. resources Finally, we have the type, which is used for variables that do not have an assigned value, NULL it is not possible to transmit to a NULL type but it is possible to assign a value of NULL to a variable. Now, PHP is a loosely-typed language, which means that a variable can change its contents during runtime. In fact, the value can change from string to integer to boolean without creating any problem with the script and even without throwing any errors. When it comes to variables, a fundamental part to understand is the so-called casting, that is, how the variable is seen by the programming language. As you’ve seen, in PHP variables can change type and understand how these changes happen behind the scenes is an essential part of the work of a web developer (not to mention the number of migraines that you will avoid). Imagine that you have a type-string variable $str containing “10”, imagine that, a couple of lines below you sum the variable with another number, let’s say $str = "10";$num = $str + 5;// $num will take the value of 15 PHP is smart enough to understand that the intention was to add the number 10 contained in the string with the number 5. The operation will parse successfully without errors and the value of $num will be 15. The reasoning that PHP does is called “casting” and I am sure you already understood that it is a powerful ace in our sleeve but at the same time can easily turn into a double-edged sword. You will see all kinds of variables and their declarations below, for further information I invite you to take a look at the official manual. Boolean variables Understanding how the Boolean variables work is the easiest thing in programming. A boolean variable indicates only one bit, thus only two values: 1 or 0, it can be true or false, yes or no, there is no other alternative, Boolean is the value that is considered during conditional statements like if, else, and cases of the switch-case. There are several rules to keep in mind regarding casting on Boolean variables. Empty arrays are counted as 0 or false; unless you consider empty stings, they are always considered true; if a string contains the number 0 the Boolean value is considered 0 or false; if a string contains any other number when cast as a boolean the value becomes true; every integer or float that does not have the value of 0 is to be considered true, this means that a negative value is true as well. The guys at techterms.com have created a brief explanation of what Boolean means and how it can be used on search conditions and search engines Check their definition Integer variables Integers are all the numbers that belong to the whole-number category. For integers, I intend all the negative and positive 0 included. Are also to be considered integer numbers in bases different from 10, in fact, in PHP you can use numbers based on binary, octal, decimal, and hexadecimal; You must use a prefix that will set the type of base you want to use 0b indicates numbers based on binary, “0b1100100” represents the value 100 in base 2, 0 followed by a number indicates that the number is to be considered octal 100 (base 10) becomes 0o144 in base (8). The prefix to use what you intend to indicate hexadecimal numbers instead is’ 0x 0x64 is the hexadecimal value to use for 100 (base 10). The range of numbers available depends on how powerful your computer is. The maximum value that variables of type integer can have is (for PC running 32 bit) and about , for 64-bit platforms. 2 billion 9E18, yes 18 zeroes The maximum value of type integer in 64-bit platform is 1000000000000000000 You can modify this limit using constants like PHP_INT_SIZE, PHP_INT_MAX and PHP_INT_MIN. But unless you work for Elon Musk and you are in charge of developing the software that will make us land on Mars I really discourage their use. (if you are and you have decided to use PHP, well, good luck with that). To be honest, it is possible to overcome this limit without using the constants but the variables will no longer be considered as integers but will be transformed into floats, here is an example available in the official manual of PHP: $number = 2147483647;// this is an integer on 32-bit machines$number = 2147483648;// this is a float on 32-bit machines You can also cast variables and make them integer using the keywords (int) or (integer) followed by the number you intend to cast. Note also that when you cast a value to integer PHP does not round above or below but simply cuts the portion of the decimal number 100.57 becomes 100 -100.57 becomes -100 when you cast a string in an integer, it will give 0 unless the string starts with a number “10 o ‘clock” becomes 10; “half past 10” becomes 0; Last note to consider is dealing with irrational numbers. look here, echo (int) ((0.1 + 0.7) * 10); Would you expect that the result would be 0.8 right? not exactly. 0.7 can be expressed as a rational number based on decimal but not on base 2. The values echoed would be 0.7. Since there is only a limited number of bits available to be saved it is inevitable that there is a loss of precision during these calculations. To be clear the internal representation of the code above will be something like 7.9999999999999991118… The degree of accuracy depends on the machine on which PHP runs, below there is a small snippet created by that allows you to check the accuracy level of your system. Andrew Beak This value is known as the machine epsilon, or unit roundoff, and is the smallest acceptable difference in calculations. $pi = 3.14159625;Indian $ = 3.2; $epsilon = 0.00001;if (abs($pi - $Indian) < $epsilon) {echo "Those values look the same";} else {echo "Those values are different";} This code checks if the values are equal to five degrees of precision. Float variables Unlike integer, float or double numbers are all numbers that are not whole-number, To make it simple, the numbers that have a comma are to be considered float. Although, as for the integer, the range of these variables depend on the power of the platform on which we work, PHP uses a standard called IEEE 754 in order to limit errors to a minimum. We have already seen however that for values such as 0.1 and 0.7 there is no exact representation which involves some issues. As regards the conversion of float variables, the procedure is rather simple and depends on the type of source variable. To integer the procedure is almost natural, just add 0.n to the number and there you go! here is a float or double number. The procedure on strings is a bit more complicated but there will be no errors if you continue to follow the rules and the string contains appropriate values. $var = 10 + "100.3";// $var is afloat and its value is 110.3$var = 7 + "11.2 kg of ham";// $var is a float and its value is 18.2 String variables After describing variables that contain numbers, now let’s talk about variables that contain characters, A character is worth one byte, which means that PHP has only 256 character characters available. PHP strings are a series of bytes. The information stored inside PHP regarding strings are their length and the content, 32-bit systems support strings as large as 2GB whereas 64-bit systems do not have any particular limit. A string can be declared using two different methods, the simple method does not evaluate control characters and variables and the complex method that takes into account variables’ value. To use the simple method you need to use the single-quote-marks while for the complex you would use the double-quote-marks $language = 'PHP';$simple = 'I code in $language';echo $simple;// The string echoed will be: I code in $language$complex = "I code in $language";echo $complex;// The string echoed will be: I code in PHP As you can see the double quotes evaluates the $language variable and show its actual value. This is a huge advantage because let you create complete strings of text without the necessity of using concatenation, which in my opinion make the code much simpler to read $city = 'London';echo 'I am a Web Developer based in ' . $city;echo "I am a Web Developer based in $city"; Did you see what I mean? A little tip that I use some time to specify to the PHP parser that I want to evaluate a variable is to use curly braces. $burger = "hamburger";echo "I love $burgers";// I love $burgersecho "I love {$burger}s";// I love hamburgers Since is not a defined variable, in the first example PHP will not evaluate it and show a plain string, in the second example the curly braces indicate that you want the variable to be evaluated so it will be shown in a plural context. $burgers You will see that there are more examples of proficient use of curly braces with strings such as using them when evaluating data within arrays and objects. Conclusion As you have also seen a basic element of programming as the variables have so much to hide and must be deepened in such a way as to be fully understood. In this blog post, we focused on scalar variables, which are the most common and elementary variables, Stay tuned, In the next episode of the series, we’re going to study composite variables like null array objects and resources. Also if you haven’t read the other parts of this series The renaissance of PHP Construct and Comments of PHP 7 Now that you understand this other basic concept of PHP it’s time to practice and start creating your own brand online. You can do it now with hosting services like Blue Host that allows you to create an account and put your work on the worldwide showcase that is the internet. Originally published at anastasionico.uk .

How to use variables (PHP 7)

When you start learning a new programming language, maybe you had been learning follow those steps: variable, assignment, string, operators… One major theme you need to focus is . Fox example: get first name from full name, find and censor all mobile numbers in message,… string operations Along the operation we usually need to process some common procedure. One repeated procedure is finding a substring and implement some operations over the substring. Maybe you had done like something like this in the very beginning of your learning path. ( * string) { ( i = 0; i < strlen(string); i++) {// logic for checking string pattern...} ...} int checkMatchStubPattern char for int return Not a wrong way, but a time consuming. You must change the checking logic in every case. More code, more bug and of course hard for maintainance. Luckily, come as a hero to solve those kind of problems: find, input validation… As a confirmation for the usage of , every programming language supports for string operations. Regular Expression - Regex Regex Regex Regular expression is a sequence of characters that define a search pattern. This pattern is then used by string searching algorithms for “find” or “find and replace” operations on strings, or for input validation. (Source: Wikipedia) is an efficient tool to solve that problem; but it comes at a price. It is really hard to read and understand (but ). First try to read the example below. Regex not hard to learn Because of complicated syntax, it is very hard to read and understand . Furthermore, you seems not to work with too often. ROI (return-on-investment) is too low; almost common you need to use can be found on the internet (password, url, IP address,…). Are you willing to spend some weeks for learning something that you only use 4 or 5 times a year? Or just skimming over some sites for the result in around 5 minutes? That way of thinking make developers tend to google some and modify to fit into their needs. Sometime it can cost some hours to a whole day for the repetition process of searching - modifying… Regex Regex Regex Regex In every angel a demon hides… solve the problem; but how about the problem of ? Fortunately, it can be solved with . Try to look at this example. Regex string operation Regex [Verbal Expressions](http://verbalexpressions.github.io/) VerEx().startOfLine().then('http').maybe('s').then('://').anythingBut(' ').endOfLine(); I hope that you will not be frustrated after reading this example. The above is defined following this rule: Verbal Expressions The URL must start with either “http” or “https”. The URL must then have “://“. The URL can have anything following “://“, as long as is not a space. The generated from the above code is: . A bit diffenret but the functional is the same. You can find the implementation of in several languages . Regex /^(?:http)(?:s)?(?:\:\/\/)(?:[^ ]*)$/ Verbal Expressions here VerbalExpressions solve the biggest probelem of . It is readable and easy-to-understand regular expressions. In my opinion, the transition from to is great as the movement from to . Regex Regex VerbalExpressions SQL ORM Anyways, still have some drawbacks. You need to install a new library to your project, sometimes it is quite painful (e.g. you client, manager… don’t think it’s neccessary). In that case, you can go to ; write the code and it will generate the for you. VerbalExpressions VerbalRegex Regex Online tool for generating Regex Try this tool by accessing . verbalregex.com Conclusion is not a replacement of ; but an easy way to write readable . It can ease the pain of , and actually make writing expressions fun again. But keep in mind that still seems to be the best choice in some complicated cases. VerbalExpressions Regex Regex Regex Regex

VerbalExpressions — RegularExpression made easy

Evolution of Localization in Swift: From Strings to String Catalogs

সুইফটে স্থানীয়করণের বিবর্তন: স্ট্রিং থেকে স্ট্রিং ক্যাটালগ পর্যন্ত

Entwicklung der Lokalisierung in Swift: Von Strings zu String-Katalogen

Evolución de la localización en Swift: de cadenas a catálogos de cadenas

Evolution de la localisation dans Swift : des chaînes aux catalogues de chaînes

स्विफ्ट में स्थानीयकरण का विकास: स्ट्रिंग्स से स्ट्रिंग कैटलॉग तक

Swift におけるローカリゼーションの進化: 文字列から文字列カタログへ

Swift 지역화의 진화: 문자열에서 문자열 카탈로그로

Evolução da localização em Swift: de strings a catálogos de strings

Эволюция локализации в Swift: от строк к каталогам строк

Swift'de Yerelleştirmenin Evrimi: Dizelerden Dize Kataloglarına

Sự phát triển của bản địa hóa trong Swift: Từ chuỗi đến danh mục chuỗi

Swift 本地化的演变：从字符串到字符串目录

Python provides many useful libraries and functions to work with strings. Sometimes, you may need to split a string at every Nth character. It can be tedious to loop through the string and extract substrings, one at a time. In this article, we will learn three simple ways to quickly split a string into substrings of N consecutive characters each. Let us say you have the following string in Python. s = '1234567890' Let us say you want to split it after every two characters. ['12','34','56','78','90'] Here are three ways to split the string as per our requirement: Using List Comprehension
Using Wrap Function
Using Regular Expression 1. Using List Comprehension In this approach, we use list comprehension along with indexes to get a list of substrings. >>> S = '1234567890'
>>> n = 2
>>> [s[i:i+n] for i in range(0, len(s), n)]
['12', '34', '56', '78', '90'] In the above code, we use range() function in list comprehension, with three arguments. The first one is 0. The second argument is the length of the string. The third argument is the step n. In our case, n=2. So the range() function returns a list of [0, n, 2n, 3n,…]. We loop through this list, using its items as list indexes. In other words, we extract substrings from original string, between index i and i+n, where i takes the values 0, n, 2n, … from output of range() function. You can include it in a function, as shown below. def split_n(s, n):
  return [s[i:i+n] for i in range(0, len(s), n)]

S = '1234567890'
split_n(S, 2)

#Output
['12', '34', '56', '78', '90'] 2. Using Wrap Function Python comes with a built-in textwrap library that provides a wrap() function. It takes two arguments - string to be split and the number of characters to be present in each substring. >>> from textwrap import wrap
>>> s = '1234567890'
>>> wrap(s, 2)
['12', '34', '56', '78', '90'] If the number of characters in the original string is not an exact multiple of N, then the last substring will contain all the remaining characters. For example, if your original string contains an odd number of characters and you want to split it into substrings of 2 characters each, then the last substring will contain only one character. >>> from textwrap import wrap
>>> s = '123456789'
>>> wrap(s, 2)
['12', '34', '56', '78', '9'] Here’s a function to split a string using wrap() from textwrap import wrap

def split_n(s, n):
  return wrap(s,n)

S = '1234567890'
split_n(S, 2)

#Output
['12', '34', '56', '78', '90'] 3. Using Regular Expression You can also use findall() function in Python’s regular expression library ‘re’ for this purpose. >>> import re
>>> re.findall('..','1234567890')
['12', '34', '56', '78', '90'] In the above code, we use a regular expression consisting of 2 dots to specify a string with two characters. If your original string has an odd number of characters and you need to split it into substrings of 2 characters each, then you can use the ‘..?’ regular expression to indicate that the second character is optional. >>> import re
>>> re.findall('..?', '123456789')
['12', '34', '56', '78', '9'] Here is a function to split strings using regular expression. import re

def split_n(s):
  return re.findall('..',s)

S = '1234567890'
split_n(S)

#Output
['12', '34', '56', '78', '90'] Conclusion In this tutorial, we learned how to split a string in Python for every Nth character. Among them, using the wrap() function is the easiest method since it is readily available and works even in case N is a variable. You do not need to change your code when the value of N changes. On the other hand, using regular expressions allows you to specify complex substring patterns instead of blindly extracting substrings of N characters each. But in this case, you need to modify your regular expression if N changes in your requirement. Python provides many useful libraries and functions to work with strings. Sometimes, you may need to split a string at every Nth character. It can be tedious to loop through the string and extract substrings, one at a time. In this article, we will learn three simple ways to quickly split a string into substrings of N consecutive characters each. Let us say you have the following string in Python. s = '1234567890' s = '1234567890' Let us say you want to split it after every two characters. ['12','34','56','78','90'] ['12','34','56','78','90'] Here are three ways to split the string as per our requirement: Using List Comprehension Using Wrap Function Using Regular Expression Using List Comprehension Using Wrap Function Using Regular Expression 1. Using List Comprehension In this approach, we use list comprehension along with indexes to get a list of substrings. >>> S = '1234567890'
>>> n = 2
>>> [s[i:i+n] for i in range(0, len(s), n)]
['12', '34', '56', '78', '90'] >>> S = '1234567890'
>>> n = 2
>>> [s[i:i+n] for i in range(0, len(s), n)]
['12', '34', '56', '78', '90'] In the above code, we use range() function in list comprehension, with three arguments. The first one is 0. The second argument is the length of the string. The third argument is the step n. In our case, n=2. So the range() function returns a list of [0, n, 2n, 3n,…]. We loop through this list, using its items as list indexes. In other words, we extract substrings from original string, between index i and i+n, where i takes the values 0, n, 2n, … from output of range() function. You can include it in a function, as shown below. def split_n(s, n):
  return [s[i:i+n] for i in range(0, len(s), n)]

S = '1234567890'
split_n(S, 2)

#Output
['12', '34', '56', '78', '90'] def split_n(s, n):
  return [s[i:i+n] for i in range(0, len(s), n)]

S = '1234567890'
split_n(S, 2)

#Output
['12', '34', '56', '78', '90'] 2. Using Wrap Function Python comes with a built-in textwrap library that provides a wrap() function. It takes two arguments - string to be split and the number of characters to be present in each substring. >>> from textwrap import wrap
>>> s = '1234567890'
>>> wrap(s, 2)
['12', '34', '56', '78', '90'] >>> from textwrap import wrap
>>> s = '1234567890'
>>> wrap(s, 2)
['12', '34', '56', '78', '90'] If the number of characters in the original string is not an exact multiple of N, then the last substring will contain all the remaining characters. For example, if your original string contains an odd number of characters and you want to split it into substrings of 2 characters each, then the last substring will contain only one character. >>> from textwrap import wrap
>>> s = '123456789'
>>> wrap(s, 2)
['12', '34', '56', '78', '9'] >>> from textwrap import wrap
>>> s = '123456789'
>>> wrap(s, 2)
['12', '34', '56', '78', '9'] Here’s a function to split a string using wrap() from textwrap import wrap

def split_n(s, n):
  return wrap(s,n)

S = '1234567890'
split_n(S, 2)

#Output
['12', '34', '56', '78', '90'] from textwrap import wrap

def split_n(s, n):
  return wrap(s,n)

S = '1234567890'
split_n(S, 2)

#Output
['12', '34', '56', '78', '90'] 3. Using Regular Expression You can also use findall() function in Python’s regular expression library ‘re’ for this purpose. >>> import re
>>> re.findall('..','1234567890')
['12', '34', '56', '78', '90'] >>> import re
>>> re.findall('..','1234567890')
['12', '34', '56', '78', '90'] In the above code, we use a regular expression consisting of 2 dots to specify a string with two characters. If your original string has an odd number of characters and you need to split it into substrings of 2 characters each, then you can use the ‘..?’ regular expression to indicate that the second character is optional. >>> import re
>>> re.findall('..?', '123456789')
['12', '34', '56', '78', '9'] >>> import re
>>> re.findall('..?', '123456789')
['12', '34', '56', '78', '9'] Here is a function to split strings using regular expression. import re

def split_n(s):
  return re.findall('..',s)

S = '1234567890'
split_n(S)

#Output
['12', '34', '56', '78', '90'] import re

def split_n(s):
  return re.findall('..',s)

S = '1234567890'
split_n(S)

#Output
['12', '34', '56', '78', '90'] Conclusion In this tutorial, we learned how to split a string in Python for every Nth character. Among them, using the wrap() function is the easiest method since it is readily available and works even in case N is a variable. You do not need to change your code when the value of N changes. On the other hand, using regular expressions allows you to specify complex substring patterns instead of blindly extracting substrings of N characters each. But in this case, you need to modify your regular expression if N changes in your requirement.

How to Split String Every Nth Character in Python

In programming, we often need to go between strings and bytes. Humans read strings. Computers read bytes. As a result, dotnet developers need to understand how to convert a string to a byte array in C#. We accomplish this through a process called encoding and decoding to go back and forth between the two. In this article, I’ll provide you code examples to convert a string to a byte array in C# — and back again! You’ll also learn about some of the nuances of character encodings to look out for! Encoding and Decoding in C# If we want to convert a string to a byte array — or go the other way — we need to understand the concept of encoding and decoding. In software engineering, encoding refers to the process of transforming a string into a sequence of bytes, while decoding involves the reverse process of transforming bytes back into a string. Simple, right? Remember that strings are a sequence of characters, and the concept of a character makes a lot of sense to us as readers, but computers understand bytes. Characters themselves can be represented by numbers in computers so when we want to work with strings at a lower level, such as when sending data over a network or storing it in a file, we need to convert the string into a byte array. Encoding comes into play when converting strings to byte arrays. It determines how the characters in the string are represented as bytes. The encoding scheme defines the mapping between characters and their byte representations. Common encoding schemes include UTF-8, UTF-16, ASCII, and Unicode. Choosing the correct encoding is important because different encoding schemes support different sets of characters. For example, ASCII only supports the basic English alphabet (with a few more characters), while UTF-8 and UTF-16 are capable of representing characters from multiple languages and scripts. More on this later though since I know you’re eager for some code! Choosing an Encoding for String to Byte Array Conversion When converting strings to byte arrays in C#, one of the most important things to consider is character encoding. Character encoding determines the mapping between characters and byte values, and if you’re considering transforming data one way then you may want to put some thought into how to transform it back! What’s that supposed to mean? Well, if we use a data transform — let’s say taking a string and transforming it to bytes with an ASCII encoding — if there is not a mapping of a particular character to a byte representation we lose that data in the result. Now what happens if you want to go the other way and get your byte array back to a string? Data is missing! In C#, there are various encodings available, including ASCII, UTF-8, and UTF-16, each with its specific characteristics and usage scenarios. Let’s explore these encodings and see how they can be used for string to byte array conversion. ASCII Encoding ASCII encoding represents characters using 7 bits, allowing for a total of 128 different characters. It’s primarily suitable for handling basic English characters and is more space-efficient compared to other encodings. Here’s an example of converting a string to a byte array using ASCII encoding: string text = "Hello, World!";
byte[] asciiBytes = Encoding.ASCII.GetBytes(text); In many modern applications, ASCII may not be what you’re after. This is especially true if you have users across the globe in locales that are not English. That’s not to say that ASCII *cannot* be used, but you’ll want to be careful about what data you ASCII encode so as to not lose information during the encoding transform. So keep in mind that the ASCII character set represents characters using a 7-bit encoding scheme, allowing for a total of 128 unique characters. However, with the growing need for internationalization and multilingual support, ASCII alone is insufficient to represent all characters effectively. Good thing we have some other options coming right up! UTF-8 Encoding UTF-8 encoding is a variable-length encoding scheme that can represent any Unicode character. It’s widely used for encoding text in various languages and is backward compatible with ASCII. It uses fewer bytes for representing ASCII characters but may require more bytes for non-ASCII characters. Here’s an example of converting a string to a byte array using UTF-8 encoding: string text = "Привет, мир!";
byte[] utf8Bytes = Encoding.UTF8.GetBytes(text); UTF-16 Encoding UTF-16 encoding represents characters using either 2 or 4 bytes, making it capable of representing any Unicode character. It’s commonly used by applications that need to handle multilingual text or when interoperability with other systems is required. The encoding can be little-endian or big-endian, with the former being more prevalent. Here’s an example of converting a string to a byte array using UTF-16 encoding: string text = "こんにちは、世界！";
byte[] utf16Bytes = Encoding.Unicode.GetBytes(text); UTF-8 Encoding vs UTF-16 Encoding – What’s The Difference? Each of these encodings is variable width, and their size gives them different characteristics when we consider different alphabets. Starting with UTF-8, it’s variable-width and backward-compatible with ASCII. In this encoding: ASCII characters, which are on the range U+0000 to U+007F, take only 1 byte.
In the next range, code points U+0080 to U+07FF take twice as much space at 2 bytes each.
Code points U+0800 to U+FFFF take one more byte, bringing us up to 3 bytes
And finally, code points U+10000 to U+10FFFF take 4 bytes. This can be very effective for English text because those characters will take up minimal space. However, when it comes to Asian text it’s not ideal for the exact opposite reason. Because UTF-16 has code points from U+0000 to U+FFFF take 2 bytes and code points U+10000 to U+10FFFF are double that at 4 bytes, it’s not-so-great for English. It *does* happen to be better suited for Asian characters though. There’s even UTF-32 encoding! This is a fixed-width encoding where all of the code points take four bytes — unlike the others I’ve mentioned which are dynamic in size. This can use much more storage than the other encodings, but because of its simplicity can be much faster to operate on. Give some consideration to the alphabets you’ll need to support primarily! Best Practices for String to Byte Array Conversion When converting strings to byte arrays in C#, it’s important to follow best practices to ensure efficiency and reliability. In this section, I’ll discuss some key best practices that you should keep in mind when performing string-to-byte array conversions. Error Handling and Validation When working with encodings, it’s important to handle potential errors and validate your data to prevent unexpected behavior in your code. Ideally, you structure the flow of your application such that you know what kind of data you’re dealing with. If you can write code to avoid errors in the first place, this is preferred! We don’t want to have to rely on this but sometimes it’s outside of our control — handling errors is by using try-catch blocks. By encapsulating the conversion code within a try block, you can catch any exceptions that may occur during the conversion process and handle them gracefully. If you don’t have control over the source of the input data, this is something you might need to do for safety. Encoding Selection C# provides several encoding options for converting strings to byte arrays, such as UTF-8, UTF-16, ASCII, and more. It’s important to select the appropriate encoding based on the specific requirements of your application. Consider factors such as character sets, compatibility with other systems, and performance implications when choosing the encoding. // Example of encoding selection
string inputString = "Hello, World!";
byte[] encodedBytes = Encoding.UTF8.GetBytes(inputString); Just like we saw in the previous examples, after the Encoding class we get to pick the static property holding the encoding instance. If we need to select one to pass around as a variable and parameter, you can absolutely store it in a dedicated encoding reference: Encoding selectedEncoding = Encoding.UTF8;
SomeMethod("Hello World!", selectedEncoding); Selecting the wrong encoding can have big consequences for your application! This is especially true if you save data with an encoding that will lose data resolution and you can’t reverse it… so put some care into this! Now You Know How to Convert a String to Byte Array in C#! You’re a pro now with encoding and decoding! Well, maybe not a full-on expert… but you have the basics put in front of you and some guidelines to work with. That’s a pretty good start. Remember to select the right encoding for the situation you’re dealing with. Keep in mind that you can potentially lose data resolution when using the wrong encoding, and as a result, lose data forever! If you found this useful and you’re looking for more learning opportunities, consider subscribing to my free weekly software engineering newsletter and check out my free videos on YouTube! In programming , we often need to go between strings and bytes. Humans read strings. Computers read bytes. As a result, dotnet developers need to understand how to convert a string to a byte array in C#. We accomplish this through a process called encoding and decoding to go back and forth between the two. programming In this article, I’ll provide you code examples to convert a string to a byte array in C# — and back again! You’ll also learn about some of the nuances of character encodings to look out for! Encoding and Decoding in C# If we want to convert a string to a byte array — or go the other way — we need to understand the concept of encoding and decoding. In software engineering, encoding refers to the process of transforming a string into a sequence of bytes, while decoding involves the reverse process of transforming bytes back into a string. Simple, right? Remember that strings are a sequence of characters, and the concept of a character makes a lot of sense to us as readers, but computers understand bytes. Characters themselves can be represented by numbers in computers so when we want to work with strings at a lower level, such as when sending data over a network or storing it in a file, we need to convert the string into a byte array. Encoding comes into play when converting strings to byte arrays. It determines how the characters in the string are represented as bytes. The encoding scheme defines the mapping between characters and their byte representations. Common encoding schemes include UTF-8, UTF-16, ASCII, and Unicode . how encoding scheme defines the mapping between characters Common encoding schemes include UTF-8, UTF-16, ASCII, and Unicode Choosing the correct encoding is important because different encoding schemes support different sets of characters. For example, ASCII only supports the basic English alphabet (with a few more characters), while UTF-8 and UTF-16 are capable of representing characters from multiple languages and scripts. More on this later though since I know you’re eager for some code! Choosing an Encoding for String to Byte Array Conversion When converting strings to byte arrays in C#, one of the most important things to consider is character encoding. Character encoding determines the mapping between characters and byte values, and if you’re considering transforming data one way then you may want to put some thought into how to transform it back! What’s that supposed to mean? Well, if we use a data transform — let’s say taking a string and transforming it to bytes with an ASCII encoding — if there is not a mapping of a particular character to a byte representation we lose that data in the result. Now what happens if you want to go the other way and get your byte array back to a string? Data is missing! In C#, there are various encodings available, including ASCII, UTF-8, and UTF-16, each with its specific characteristics and usage scenarios. Let’s explore these encodings and see how they can be used for string to byte array conversion. ASCII Encoding ASCII encoding represents characters using 7 bits, allowing for a total of 128 different characters. It’s primarily suitable for handling basic English characters and is more space-efficient compared to other encodings. Here’s an example of converting a string to a byte array using ASCII encoding: string text = "Hello, World!";
byte[] asciiBytes = Encoding.ASCII.GetBytes(text); string text = "Hello, World!";
byte[] asciiBytes = Encoding.ASCII.GetBytes(text); In many modern applications, ASCII may not be what you’re after. This is especially true if you have users across the globe in locales that are not English. That’s not to say that ASCII *cannot* be used, but you’ll want to be careful about what data you ASCII encode so as to not lose information during the encoding transform. So keep in mind that the ASCII character set represents characters using a 7-bit encoding scheme, allowing for a total of 128 unique characters. However, with the growing need for internationalization and multilingual support, ASCII alone is insufficient to represent all characters effectively. Good thing we have some other options coming right up! UTF-8 Encoding UTF-8 encoding is a variable-length encoding scheme that can represent any Unicode character. It’s widely used for encoding text in various languages and is backward compatible with ASCII. It uses fewer bytes for representing ASCII characters but may require more bytes for non-ASCII characters. Here’s an example of converting a string to a byte array using UTF-8 encoding: string text = "Привет, мир!";
byte[] utf8Bytes = Encoding.UTF8.GetBytes(text); string text = "Привет, мир!";
byte[] utf8Bytes = Encoding.UTF8.GetBytes(text); UTF-16 Encoding UTF-16 encoding represents characters using either 2 or 4 bytes, making it capable of representing any Unicode character. It’s commonly used by applications that need to handle multilingual text or when interoperability with other systems is required. The encoding can be little-endian or big-endian, with the former being more prevalent. Here’s an example of converting a string to a byte array using UTF-16 encoding: string text = "こんにちは、世界！";
byte[] utf16Bytes = Encoding.Unicode.GetBytes(text); string text = "こんにちは、世界！";
byte[] utf16Bytes = Encoding.Unicode.GetBytes(text); UTF-8 Encoding vs UTF-16 Encoding – What’s The Difference? Each of these encodings is variable width, and their size gives them different characteristics when we consider different alphabets. Starting with UTF-8, it’s variable-width and backward-compatible with ASCII. In this encoding: ASCII characters, which are on the range U+0000 to U+007F, take only 1 byte. In the next range, code points U+0080 to U+07FF take twice as much space at 2 bytes each. Code points U+0800 to U+FFFF take one more byte, bringing us up to 3 bytes And finally, code points U+10000 to U+10FFFF take 4 bytes. ASCII characters, which are on the range U+0000 to U+007F, take only 1 byte. In the next range, code points U+0080 to U+07FF take twice as much space at 2 bytes each. Code points U+0800 to U+FFFF take one more byte, bringing us up to 3 bytes And finally, code points U+10000 to U+10FFFF take 4 bytes. This can be very effective for English text because those characters will take up minimal space. However, when it comes to Asian text it’s not ideal for the exact opposite reason. Because UTF-16 has code points from U+0000 to U+FFFF take 2 bytes and code points U+10000 to U+10FFFF are double that at 4 bytes, it’s not-so-great for English. It *does* happen to be better suited for Asian characters though. There’s even UTF-32 encoding! This is a fixed-width encoding where all of the code points take four bytes — unlike the others I’ve mentioned which are dynamic in size. This can use much more storage than the other encodings, but because of its simplicity can be much faster to operate on. Give some consideration to the alphabets you’ll need to support primarily! Best Practices for String to Byte Array Conversion When converting strings to byte arrays in C#, it’s important to follow best practices to ensure efficiency and reliability. In this section, I’ll discuss some key best practices that you should keep in mind when performing string-to-byte array conversions. Error Handling and Validation When working with encodings, it’s important to handle potential errors and validate your data to prevent unexpected behavior in your code. Ideally, you structure the flow of your application such that you know what kind of data you’re dealing with. If you can write code to avoid errors in the first place, this is preferred! We don’t want to have to rely on this but sometimes it’s outside of our control — handling errors is by using try-catch blocks. By encapsulating the conversion code within a try block, you can catch any exceptions that may occur during the conversion process and handle them gracefully. If you don’t have control over the source of the input data, this is something you might need to do for safety. Encoding Selection C# provides several encoding options for converting strings to byte arrays, such as UTF-8, UTF-16, ASCII, and more. It’s important to select the appropriate encoding based on the specific requirements of your application. Consider factors such as character sets, compatibility with other systems, and performance implications when choosing the encoding. // Example of encoding selection
string inputString = "Hello, World!";
byte[] encodedBytes = Encoding.UTF8.GetBytes(inputString); // Example of encoding selection
string inputString = "Hello, World!";
byte[] encodedBytes = Encoding.UTF8.GetBytes(inputString); Just like we saw in the previous examples, after the Encoding class we get to pick the static property holding the encoding instance. If we need to select one to pass around as a variable and parameter, you can absolutely store it in a dedicated encoding reference: Encoding selectedEncoding = Encoding.UTF8;
SomeMethod("Hello World!", selectedEncoding); Encoding selectedEncoding = Encoding.UTF8;
SomeMethod("Hello World!", selectedEncoding); Selecting the wrong encoding can have big consequences for your application! This is especially true if you save data with an encoding that will lose data resolution and you can’t reverse it… so put some care into this! Now You Know How to Convert a String to Byte Array in C#! You’re a pro now with encoding and decoding! Well, maybe not a full-on expert… but you have the basics put in front of you and some guidelines to work with. That’s a pretty good start. Remember to select the right encoding for the situation you’re dealing with. Keep in mind that you can potentially lose data resolution when using the wrong encoding, and as a result, lose data forever! If you found this useful and you’re looking for more learning opportunities, consider subscribing to my free weekly software engineering newsletter and check out my free videos on YouTube ! subscribing to my free weekly software engineering newsletter free videos on YouTube

How to Convert a String to Byte Array in C#

The article demonstrates the importance of using StringComparison options for efficient string comparison in .NET Introduction Whether it's searching, sorting, or equality, how you compare strings can significantly impact your application performance. The article demonstrates the importance of using StringComparison options for efficient string comparison in .NET Learning Objectives The Problem with Inefficient String Comparisons Efficient String Comparison with StringComparison Choosing the Right StringComparison Option Prerequisites for Developers Basic understanding of C# programming language. 30 Day .Net Challenge Getting Started The Problem with Inefficient String Comparisons Consider the following common approach used by most developers for string comparison: // Inefficient string comparison
    bool equal = string1.ToLower() == string2.ToLower(); The ToLower method creates a new string memory allocation for each comparison, leading to unnecessary allocations. Consider a method with frequent requests that can degrade the application performance. The ToLower method is culture-sensitive, which means it might produce different results depending on the current culture set in the executing thread. Efficient String Comparison with StringComparison .NET provides a powerful enumeration, StringComparison, designed to address these inefficiencies. // Efficient string comparison
    bool equal = string.Equals(string1, string2, StringComparison.OrdinalIgnoreCase); The aforementioned addresses both of the problems in the old string comparison way. No Unnecessary Allocations Improved Performance Choosing the Right StringComparison Option Use for most general-purpose comparisons where cultural rules are not relevant. This is the fastest option. Ordinal: Ideal for case-insensitive comparisons where cultural rules do not apply. OrdinalIgnoreCase: **CurrentCulture and CurrentCultureIgnoreCase: **Use when comparing strings displayed to the user, where adherence to cultural rules is important. Suitable for scenarios requiring consistency across different cultures, such as storing and retrieving data. InvariantCulture and InvariantCultureIgnoreCase: Create another class named StringComparisons and add the following code snippet public static class StringComparisons
    {
        private static readonly string string1 = "test";
        private static readonly string string2 = "test";
        public static void BadMethod()
        {
            // Inefficient string comparison
            bool equal = string1.ToLower() == string2.ToLower();
            Console.WriteLine($"In bad method strings are {equal}");
        }
    
        public static void GoodMethod()
        {
            // efficient string comparison
            bool equal = string.Equals(string1, string2, System.StringComparison.OrdinalIgnoreCase);
            Console.WriteLine($"In good method strings are {equal}");
        }
    } Execute from the main method as follows #region Day 21: String Comparisons
    static string ExecuteDay21()
    {
        StringComparisons.BadMethod();
        StringComparisons.GoodMethod();
    
        return "Executed Day 21 successfully..!!";
    }
    
    #endregion Console output In bad method strings are True
    In good method strings are True Complete Code on GitHub GitHub — ssukhpinder/30DayChallenge.Net C# Programming🚀 Thank you for being a part of the C# community! Before you leave: Follow us: | | | Visit our other platforms: More content at Youtube X LinkedIn Dev.to GitHub C# Programming

The 30-Day .NET Challenge - Day 21: StringComparison

Introduction The article demonstrates the IndexOfAny() method to locate the initial occurrence of any string from a chosen array. Additionally, you utilize LastIndexOf() to pinpoint the last occurrence of a string within another string. Learning Objectives Learn to use LastIndexOf() method Learn to use IndexOfAny() method Prerequisites for Developers Basic familiarity with string helper methods Basic understanding of while iteration statements Proficiency in using Visual Studio or Visual Studio Code for C# code development, building, and execution Getting Started LastIndexOf Method To enhance the complexity of the “message” variable by incorporating numerous sets of parentheses, followed by coding to extract the content enclosed within the last set of parentheses. To begin, create a static class file called “StringMethodsPart2.cs” within the console application. Insert the provided code snippet into this file. public static class StringMethodsPart2
{
    /// <summary>
    /// Outputs
    /// Searching THIS message: Help (find) the {opening symbols}
    /// Found WITHOUT using startPosition: (find) the { opening symbols }
    /// </summary>
    public static void IndexOfAnyMethod()
    {
        string message = "Help (find) the {opening symbols}";
        Console.WriteLine($"Searching THIS Message: {message}");
        char[] openSymbols = ['[', '{', '('];

        int openingPosition = message.IndexOfAny(openSymbols);
        Console.WriteLine($"Found WITHOUT using startPosition: {message.Substring(openingPosition)}");

    }
} Execute the code from the main method as follows #region Day 7 - String built-in methods Part 2

StringMethodsPart2.IndexOfAnyMethod();

#endregion Console Output set of parentheses IndexOfAny Method Utilize .IndexOfAny() to retrieve the index of the initial symbol from the openSymbols array that is present in the message string. To do that, add another method into the same static class as shown below /// <summary>
/// Outputs
/// set of parentheses
/// </summary>
public static void LastIndexOfMethod() {

    string message = "(What if) I am (only interested) in the last (set of parentheses)?";
    int openingPosition = message.LastIndexOf('(');

    openingPosition += 1;
    int closingPosition = message.LastIndexOf(')');
    int length = closingPosition - openingPosition;
    Console.WriteLine(message.Substring(openingPosition, length));
} Execute the code from the main method as follows #region Day 7 - String built-in methods Part 2

StringMethodsPart2.LastIndexOfMethod();

#endregion Console Output Searching THIS message: Help (find) the {opening symbols}
Found WITHOUT using startPosition: (find) the {opening symbols} Complete Code on GitHub GitHub — ssukhpinder/30DayChallenge.Net C# Programming🚀 Thank you for being a part of the C# community! Before you leave: If you’ve made it this far, please show your appreciation with a clap and follow the author! 👏️️ Follow us: | | | | | X LinkedIn Dev.to Hashnode Newsletter Tumblr Visit our other platforms: | | | | GitHub Instagram Tiktok Quora Daily.dev More content at C# Programming Also published . here

The 30-Day .NET Challenge, Day 7: String Built-in Methods Part 2

Introduction The module demonstrates string-helper methods to pinpoint and extract the desired information. Learning Objectives Locate the position of a character or substring within another string Retrieve segments of strings Prerequisites for Developers Basic familiarity with string helper methods Basic understanding of while iteration statements Proficiency in using Visual Studio or Visual Studio Code for C# code development, building, and execution Getting Started IndexOf method Utilize the IndexOf() method to find the position of a single or multiple characters/strings within a larger string. To begin, create a static class file called “StringMethods.cs” within the console application. Insert the provided code snippet into this file. public static class StringMethods
{
/// <summary>
/// Outputs
/// 13
/// 36
/// </summary>
public static void IndexOfExample()
{
string message = "Find what is (inside the parentheses)"; int openingPosition = message.IndexOf('(');
    int closingPosition = message.IndexOf(')');

    Console.WriteLine(openingPosition);
    Console.WriteLine(closingPosition);
} } Execute the code from the main method as follows #region Day 6 - String built-in methods StringMethods.IndexOfExample(); #endregion Console Output 13
36 Substring method Use the Substring() method to extract the part of the main string that comes after the specified character positions. To do that, add another method into the same static class as shown below /// <summary>
/// Outputs
/// (inside the parentheses
/// </summary>
public static void SubstringExample()
{
string message = "Find what is (inside the parentheses)"; int openingPosition = message.IndexOf('(');
int closingPosition = message.IndexOf(')');

int length = closingPosition - openingPosition;
Console.WriteLine(message.Substring(openingPosition, length)); Execute the code from the main method as follows #region Day 6 - String built-in methods

StringMethods.SubstringExample();

#endregion Console Output (inside the parentheses Skip the first character “(” Simply update the starting index position using openingPosition += 1; To do that, add another method into the same static class as shown below /// <summary>
/// Outputs
/// inside the parentheses
/// </summary>
public static void SubstringExample2()
{
    string message = "Find what is (inside the parentheses)";

    int openingPosition = message.IndexOf('(');
    int closingPosition = message.IndexOf(')');

    openingPosition += 1;

    int length = closingPosition - openingPosition;
    Console.WriteLine(message.Substring(openingPosition, length));
} Execute the code from the main method as follows #region Day 6 - String built-in methods

StringMethods.SubstringExample2();

#endregion Console Output inside the parentheses Complete Code on GitHub GitHub — ssukhpinder/30DayChallenge.Net C# Programming🚀 Thank you for being a part of the C# community! Before you leave: If you’ve made it this far, please show your appreciation with a clap and follow the author! 👏️️ Follow us: | | | | | X LinkedIn Dev.to Hashnode Newsletter Tumblr Visit our other platforms: | | | | GitHub Instagram Tiktok Quora Daily.dev More content at C# Programming Also published . here

The 30-Day .NET Challenge Day 6: String built-in Methods

Authors: (1) Gopal Yadav, Department of Physics, Indian Institute of Technology & Chennai Mathematical Institute. Table of Links Abstract Acknowledgment PART I Chapter 1: Introduction Chapter 2: SU(3) LECs from Type IIA String Theory Chapter 3: Deconfinement Phase Transition in Thermal QCD-Like Theories at Intermediate Coupling in the Absence and Presence of Rotation Chapter 4: Conclusion and Future Outlook PART II Chapter 5: Introduction Chapter 6: Page Curves of Reissner-Nordström Black Hole in HD Gravity Chapter 7: Entanglement Entropy and Page Curve from the M-Theory Dual of Thermal QCD Above Tc at Intermediate Coupling Chapter 8: Black Hole Islands in Multi-Event Horizon Space-Times Chapter 9: Multiverse in Karch-Randall Braneworld Chapter 10: Conclusion and Future outlook APPENDIX A APPENDIX B APPENDIX C Bibliography CHAPTER 2 - SU(3) LECS FROM TYPE IIA STRING THEORY This chapter is based on the paper [2]. Some portion of [2] is already present in a thesis of one of the co-authors (VY) [83]. Detailed calculations of the relevant quantities appearing in this chapter are given in [83]. Hence, we will quote those results in appendix A without going into the details and use those results to calculate the low energy coupling constants (LECs) of SU(3) chiral perturbation theory in the chiral limit. 2.1 Introduction Holographic computation of SU(3) LECs was done in [84] from the top-down Sakai-Sugimoto model [90]. The Sakai-Sugimoto model is not UV complete. The Lagrangian obtained in [84] is different from the SU(3) χPT Lagrangian given in [87]. The paper [91] contains the relationship between the SU(3) LECs and the coupling constants obtained in [84]. We obtained these LECs from a UV complete top-down holographic dual. The gravity dual is type IIA string theory in the presence of higher derivative terms. Type IIA background had been obtained by descending back from the M-theory to type IIA string theory. 2.2 SU(3) Chiral Perturbation Theory Lagrangian and the Phenomenological Values of LECs The term appearing in the SU(3) χPT Lagrangian at O(p 4 ) with one-loop renormalized low energy constants (LECs),Li and Hi , in chiral limit are written as follows [87]: The divergent piece, λ(µ) appearing in (2.2) is given below. where d = 4. The phenomenological values of the one-loop renormalized SU(3) LECs appearing in (2.1) are listed in the table 2.1 [89]. In table 2.2 sources from where the LECs have been extracted is given for the column titled GL 1985 [87]. In the chiral perturbation theory that is used in gauge-gravity duality, the holographic renormalization acts as the analogue of the one-loop renormalization. The eleven dimensional on-shell supergravity action including O(β) correction was worked out in [3] and written below: 2.3 Holographic Computation of SU(3) LECs The simplified expressions of the radial integrals appearing in (2.18) are given in the appendix A. Relation between SU(3) LECs of [87] (equation (2.1)) and couplings appearing from holographic computation (equation (2.15)) was obtained in [91]: 2.4 Summary In this chapter, we computed the LECs of SU(3) chiral perturbation theory from the type IIA string dual inclusive of O(R4 ) corrections. We constructed the SU(3) Lagrangian and obtained the coupling constants from the radial integrals quoted in appendix A. We already mention in the beginning of this chapter that we have used the results of [2, 83] to do our calculations in this chapter. My contribution has been presented in this chapter. All the above points are summarised in the table 2.3. This paper is under CC 4.0 license. available on arxiv

Stories, News & Mentions about STRING

String’s Stories on HackerNoon