A delimiter is a sequence of one or more characters for specifying the boundary between separate, independent regions in plain text, mathematical expressions or other data streams.[1][2] An example of a delimiter is the comma character, which acts as a field delimiter in a sequence of comma-separated values. Another example of a delimiter is the time gap used to separate letters and words in the transmission of Morse code.[citation needed]
In mathematics, delimiters are often used to specify the scope of an operation, and can occur both as isolated symbols (e.g., colon in "") and as a pair of opposing-looking symbols (e.g., angled brackets in ).
Delimiters represent one of various means of specifying boundaries in a data stream. Declarative notation, for example, is an alternate method (without the use of delimiters) that uses a length field at the start of a data stream to specify the number of characters that the data stream contains.[3]
YouTube Encyclopedic
-
1/5Views:401 837430 5943 05932 432614
-
Check for balanced parentheses using stack
-
Intro to LaTeX : Learn to write beautiful math equations
-
Data Structure - Stack | Delimiter Matching Using Stack | With Implementation in Java
-
How to convert strings to numbers in C
-
PHP: Syntax Delimiter
Transcription
In our previous lesson, we saw one simple application of stack we saw that stack can be used to reverse a list or collection or may be to simply traverse a list or collection in reverse order. In this lesson, we will discuss another famous problem that can be solved using stack. And this is also a popular programming interview question and the problem is, given an expression in the form of a string comprising of let's say constants,variables, operators and parenthesis and when I say parenthesis I also want to include curly braces and brackets and my definition of parenthesis. so my expression or string can contain characters that can be upper or lower case letters, symbols for operators and an opening or closing parenthesis or an opening or closing curly brace on an opening or closing square bracket. Let's write down some expressions here. I'm going to write a simple expression. We have one simple expression with one pair of opening and closing parenthesis. Here in this expression we have nested parenthesis. Now given such expressions we want to write a program that would tell us whether parenthesis in the expression are balanced or not and what do we really mean by balanced parenthesis what we mean by balanced parenthesis is that corresponding to each opening parenthesis or opening curly brace or opening bracket we should have a closing counter part in correct order. These two expressions here are balanced. However this next expression is not balanced.A closing curly brace is missing here This next expression is also not balanced because we're missing an opening square bracket here. This next one is also not balanced because corresponding to this opening curly brace we do not have a closing curly brace and corresponding to this closing parenthesis we do not have an opening parenthesis. if we are opening with a curly brace,we should also close with a curly brace.These 2 count for each other.Checking for balanced parenthesis is one of the tasks performed by a compiler, when we write a program we often miss an opening or closing curly brace or an opening or closing parenthesis. Compiler must check for this balancing and if symbols are not balanced it should give you an error.In this problem here what's inside parenthesis does not matter, we do not want to check for correctness of anything that is inside a parenthesis so in the string any character other than opening and closing parenthesis or opening and closing curly brace or opening and closing square bracket can be ignored. This problem sometimes is better stated like this "Given a string comprising only of opening and closing characters of parenthesis braces or brackets we want to check for balancing". So only these characters and their order is important. While parsing a real expression we can simply ignore other characters. All we care about is these characters and their order. Okay so now how do we solve this problem?. One straight forward thing that comes to mind is that because we should have a closing counter part for an opening parenthesis or opening curly brace or opening square bracket what we can do is, we can count the number of opening and closing symbols for each of these three types and they should be equal. So the number of opening parenthesis should be equal to number of closing parenthesis. and the number of opening curly braces should be equal to number of closings curly braces and same should be true for square brackets as well but it will not be good enough this expression here has one opening parenthesis and one closing parenthesis but it's not balanced this next one is balanced but this one with same number of characters of each type as the second expression is not balanced so this approach won't work. Apart from count being equal that are some other properties that must be conserved. Every opening parenthesis must find a closing counterpart to its right and every closing parenthesis must find an opening counterpart in its left which is not true in the first expression. And the other property that must be conserved is that a parenthesis can close only when all the parenthesis opened after it are closed. This parenthesis has been opened after this square bracket so this square bracket can not close unless this parenthesis is closed. Anything that is opened last should be closed first. Well actually it should not be last opened first closed in this example here this is getting opened last but this guy I that is open previous to this is closed first and it is fine. The property that must be conserved is that as we scan the expression from left to right any closer should be for the previous unclosed parenthesis any closer should be for the last unclosed. Let's scan some expressions from left to right and see how it's true. Let's scan this last one we will go from left to right first character an opening of the square bracket second one is an opening parenthesis Lets mark opening of closed parenthesis in red. Okay now we have a closer here , the third character is a closer. this should be the closer for last unclosed. So this should be the closer for this one, this guy, this opening parenthesis. last unclosed now is this guy. Next character once again is an opening parenthesis. Now we have two unclosed parenthesis at this stage and this one is the last unclosed, the next one's a closure.So it should be closer for the last unclosed. Now the last unclosed once again is the opening of square bracket now when we have a closer it should be closer for this guy. we can use this approach to solve this problem what we can do is we can scan the expression from left to right and as we scan at any stage we can keep track of all the unclosed parenthesis basically what we can do is whenever we get an opening symbol an opening parenthesis an opening curly brace or an opening square bracket, we can add it to a list. If we get up closing symbol it should be the closer for the last element in the list, in case of an inconsistency like if the last opening symbol in the list is not of the same type as the closing symbol or if there is no last opening symbol at all because the list is empty. We can stop this whole process and say that parenthesis are not balanced else we can removed the last opening symbol in the list because we have got its counterpart and continue this whole process. Things will be further clear if I will run through an example. I will run through this last example once again. We are going to scan this expression from left to right and we will maintain a list to keep track of all the opening parenthesis that are not yet closed. We will keep the track of all the unclosed parenthesis opened but not closed. Initially this list is empty, the first character that we have got is an opening of square bracket. This will go into the list and we will move to the next character the next character is an opening parenthesis so one stick, once again it should go to the list. We should always insert at the end in the list. the next character is a closing of parenthesis now we must look at the last opening symbol in the list and if it is of the same type then we have got it's counterpart and we should remove this. Now we move on to the next character this is once again an opening parenthesis, it should go in the list at the end. The next character is a closing of parenthesis so we will look at the last element in the list, it's an opening parenthesis, so we can remove it from the list and now we go to the last character which is a closing of square bracket once again we need to look at the last element in the list we have one element only one element in the list at this stage, its an opening of square bracket so once again we can remove it from the list. Now we're done scanning the list and the list is empty once again if everything is alright if parenthesis are balanced we will always end with an empty list and if list is not empty then some opening parenthesis haven't found its closing counterpart and expression is not balanced. One thing worth noticing here is that we are always inserting and removing one element at a time from the same end of the list in this whole process whatever is coming in last in the list is going out first, there is a special kind of list that enforces this behavior that element should be inserted and removed from the same end and we call it a stack. In a stack we can insert and remove an element one at a time from the same end in constant time. so what we can do is whenever we get an opening symbol while scanning the list we can push it onto the stack and when we get a closing symbol we can check whether the opening symbol at the top of stack is of the same type has the closing symbol, if its of the same type we can pop, if it's not of the same type we can simply say that parenthesis are not balanced I will quickly write pseudocode for this logic I'm going to write a function named CheckBalancedParenthesis() that will take an expression in the form of a string as argument. first of all iI will store the number of characters in the string in a variable and then I will create a stack and I will create a stack of characters and now I will scan the expression from left to right using a loop, while scanning if the character is an opening symbol if it's an opening parenthesis or opening curly brace or opening square bracket we can push that character onto the stack, let's say this function Push() will push up character onto S else if exp[i] or the character at ith position while scanning is a closing symbol of any of the three types. We can have two scenarios if stack is empty, or top of stack does not pair with the closing symbol if we have a closing of Parenthesis then the top of stack should be an opening of Parenthesis. It cannot be an opening of curly brace, in such a scenario we can conclude that the parenthesis are not balanced else we can perform a pop. Finally once a scanning is over we can check whether a stack is empty or not if it's empty Parenthesis are balanced if it's not they are not balanced. so this is my pseudo code let's run through a couple of examples and see whether this works for all scenarios all test cases or not. Let's first look at this expression, the first thing that we're doing in our code is that we're creating a stack of characters, I have drawn logical representation of a stack here. Okay now let's scan this string, let's say we have a zero-based index and a string is just are character array, we are starting the scan and going inside the loop. This is a closing of Parenthesis so this if statement will not hold true so we will go to the else condition and now we will go inside the else to check for this condition whether stack is empty or not or whether the top of stack pairs with this closing symbol or not, the stack is empty, if the stack is empty there is no opening counterpart for this closing symbol. so we will simply return false, returning means exiting the function so we are simply concluding here that Parenthesis are not balanced and exiting. Let's go through this one now, first we have an opening squad bracket so here we go to the first if and push, next one is an opening parenthesis once again it will be pushed next one is a closing square bracket, so the condition for this else if will be true we will go inside this else if, now this time to top of stack is an opening parenthesis it should have been an opening square bracket and then only we would have a pair so this time also we will have to return false and exit. Okay now let's go through this one. First we'll have a push, the next one will also be a push, now next one is a closer of parenthesis which pairs with the top of stack which is opening of parenthesis so we will have a pop, we will go to the next character and this one once again is an opening parenthesis so there will be a push. next one is a closing parenthesis and the top is an opening parenthesis ,they pair so there will be a pop, last character is a closing curly brace so once again we will see whether the top of stack is an opening curly brace or not? do we have a pair or not? yes we have a pair so there will be a pop with this our scanning will finish and finally stack should be empty it is empty so we have balanced Parenthesis here try implementing this pseudo code in the language of your choice and see whether it works for all test cases or not. If you want to look at my implementation you can check the description of this video for a link. In the coming lessons we will see some more problems on stack. This is it for this lesson, thanks for watching!!
Overview
Delimiters may be characterized as field and record delimiters, or as bracket delimiters.
Field and record delimiters
Field delimiters separate data fields. Record delimiters separate groups of fields.[4]
For example, the CSV format uses a comma as the delimiter between fields, and an end-of-line indicator as the delimiter between records:
fname,lname,age,salary nancy,davolio,33,$30000 erin,borakova,28,$25250 tony,raphael,35,$28700
This specifies a simple flat-file database table using the CSV file format.
Bracket delimiters
Bracket delimiters, also called block delimiters, region delimiters, or balanced delimiters, mark both the start and end of a region of text.[5][6]
Common examples of bracket delimiters include:[7]
| Delimiters | Description |
|---|---|
( )
|
Parentheses. The Lisp programming language syntax is cited as recognizable primarily by its use of parentheses.[8] |
{ }
|
Braces (also called curly brackets[9]). |
[ ]
|
Brackets (commonly used to denote a subscript). |
< >
|
Angle brackets.[10] |
" "
|
commonly used to denote string literals.[11] |
' '
|
commonly used to denote character literals.[11] |
<? ?>
|
used to indicate XML processing instructions.[12] |
/* */
|
used to denote comments in some programming languages.[13] |
<% %>
|
used in some web templates to specify language boundaries.[14] |
Conventions
Historically, computing platforms have used certain delimiters by convention.[15][16] The following tables depict a few examples for comparison.
Programming languages (See also, Comparison of programming languages (syntax)).
| String Literal | End of Statement | |
|---|---|---|
| Pascal | singlequote | semicolon |
| Python | doublequote, singlequote | end of line (EOL) |
Field and Record delimiters (See also, ASCII, Control character).
| End of Field | End of Record | End of File | |
|---|---|---|---|
| Unix-like systems including macOS, AmigaOS | Tab | LF | none |
| Windows, MS-DOS, OS/2, CP/M | Tab | CRLF | none (except in CP/M), Control-Z[17] |
| Classic Mac OS, Apple DOS, ProDOS, GS/OS | Tab | CR | none |
| ASCII/Unicode | UNIT SEPARATOR Position 31 (U+001F) |
RECORD SEPARATOR Position 30 (U+001E) |
FILE SEPARATOR Position 28 (U+001C) |
Delimiter collision
Delimiter collision is a problem that occurs when an author or programmer introduces delimiters into text without actually intending them to be interpreted as boundaries between separate regions.[4][18] In the case of XML, for example, this can occur whenever an author attempts to specify an angle bracket character.
In most file types there is both a field delimiter and a record delimiter, both of which are subject to collision. In the case of comma-separated values files, for example, field collision can occur whenever an author attempts to include a comma as part of a field value (e.g., salary = "$30,000"), and record delimiter collision would occur whenever a field contained multiple lines. Both record and field delimiter collision occur frequently in text files.
In some contexts, a malicious user or attacker may seek to exploit this problem intentionally. Consequently, delimiter collision can be the source of security vulnerabilities and exploits. Malicious users can take advantage of delimiter collision in languages such as SQL and HTML to deploy such well-known attacks as SQL injection and cross-site scripting, respectively.
Solutions
Because delimiter collision is a very common problem, various methods for avoiding it have been invented. Some authors may attempt to avoid the problem by choosing a delimiter character (or sequence of characters) that is not likely to appear in the data stream itself. This ad hoc approach may be suitable, but it necessarily depends on a correct guess of what will appear in the data stream, and offers no security against malicious collisions. Other, more formal conventions are therefore applied as well.
ASCII delimited text
The ASCII and Unicode character sets were designed to solve this problem by the provision of non-printing characters that can be used as delimiters. These are the range from ASCII 28 to 31.
| ASCII Dec | Symbol | Unicode Name | Common Name | Usage |
|---|---|---|---|---|
| 28 | ␜ | INFORMATION SEPARATOR FOUR | file separator | End of file. Or between a concatenation of what might otherwise be separate files. |
| 29 | ␝ | INFORMATION SEPARATOR THREE | group separator | Between sections of data. Not needed in simple data files. |
| 30 | ␞ | INFORMATION SEPARATOR TWO | record separator | End of a record or row. |
| 31 | ␟ | INFORMATION SEPARATOR ONE | unit separator | Between fields of a record, or members of a row. |
The use of ASCII 31 Unit separator as a field separator and ASCII 30 Record separator solves the problem of both field and record delimiters that appear in a text data stream.[19]
Escape character
One method for avoiding delimiter collision is to use escape characters. From a language design standpoint, these are adequate, but they have drawbacks:
- text can be rendered unreadable when littered with numerous escape characters, a problem referred to as leaning toothpick syndrome (due to use of \ to escape / in Perl regular expressions, leading to sequences such as "\/\/");
- text becomes difficult to parse through regular expression
- they require a mechanism to "escape the escapes" when not intended as escape characters; and
- although easy to type, they can be cryptic to someone unfamiliar with the language.[20]
- they do not protect against injection attacks [citation needed]
Escape sequence
Escape sequences are similar to escape characters, except they usually consist of some kind of mnemonic instead of just a single character. One use is in string literals that include a doublequote (") character. For example in Perl, the code:
print "Nancy said \x22Hello World!\x22 to the crowd."; ### use \x22
produces the same output as:
print "Nancy said \"Hello World!\" to the crowd."; ### use escape char
One drawback of escape sequences, when used by people, is the need to memorize the codes that represent individual characters (see also: character entity reference, numeric character reference).
Dual quoting delimiters
In contrast to escape sequences and escape characters, dual delimiters provide yet another way to avoid delimiter collision. Some languages, for example, allow the use of either a single quote (') or a double quote (") to specify a string literal. For example, in Perl:
print 'Nancy said "Hello World!" to the crowd.';
produces the desired output without requiring escapes. This approach, however, only works when the string does not contain both types of quotation marks.
Padding quoting delimiters
In contrast to escape sequences and escape characters, padding delimiters provide yet another way to avoid delimiter collision. Visual Basic, for example, uses double quotes as delimiters. This is similar to escaping the delimiter.
print "Nancy said ""Hello World!"" to the crowd."
produces the desired output without requiring escapes. Like regular escaping it can, however, become confusing when many quotes are used. The code to print the above source code would look more confusing:
print "print ""Nancy said """"Hello World!"""" to the crowd."""
Configurable alternative quoting delimiters
In contrast to dual delimiters, multiple delimiters are even more flexible for avoiding delimiter collision.[7]: 63
For example, in Perl:
print qq^Nancy doesn't want to say "Hello World!" anymore.^;
print qq@Nancy doesn't want to say "Hello World!" anymore.@;
print qq(Nancy doesn't want to say "Hello World!" anymore.);
all produce the desired output through use of quote operators, which allow any convenient character to act as a delimiter. Although this method is more flexible, few languages support it. Perl and Ruby are two that do.[7]: 62 [21]
Content boundary
A content boundary is a special type of delimiter that is specifically designed to resist delimiter collision. It works by allowing the author to specify a sequence of characters that is guaranteed to always indicate a boundary between parts in a multi-part message, with no other possible interpretation.[22]
The delimiter is frequently generated from a random sequence of characters that is statistically improbable to occur in the content. This may be followed by an identifying mark such as a UUID, a timestamp, or some other distinguishing mark. Alternatively, the content may be scanned to guarantee that a delimiter does not appear in the text. This may allow the delimiter to be shorter or simpler, and increase the human readability of the document. (See e.g., MIME, Here documents).
Whitespace or indentation
Some programming and computer languages allow the use of whitespace delimiters or indentation as a means of specifying boundaries between independent regions in text.[23]
Regular expression syntax
In specifying a regular expression, alternate delimiters may also be used to simplify the syntax for match and substitution operations in Perl.[24]
For example, a simple match operation may be specified in Perl with the following syntax:
$string1 = 'Nancy said "Hello World!" to the crowd.'; # specify a target string
print $string1 =~ m/[aeiou]+/; # match one or more vowels
The syntax is flexible enough to specify match operations with alternate delimiters, making it easy to avoid delimiter collision:
$string1 = 'Nancy said "http://Hello/World.htm" is not a valid address.'; # target string
print $string1 =~ m@http://@; # match using alternate regular expression delimiter
print $string1 =~ m{http://}; # same as previous, but different delimiter
print $string1 =~ m!http://!; # same as previous, but different delimiter.
Here document
A Here document allows the inclusion of arbitrary content by describing a special end sequence. Many languages support this including PHP, bash scripts, ruby and perl. A here document starts by describing what the end sequence will be and continues until that sequence is seen at the start of a new line.[25]
Here is an example in perl:
print <<ENDOFHEREDOC;
It's very hard to encode a string with "certain characters".
Newlines, commas, and other characters can cause delimiter collisions.
ENDOFHEREDOC
This code would print:
It's very hard to encode a string with "certain characters". Newlines, commas, and other characters can cause delimiter collisions.
By using a special end sequence all manner of characters are allowed in the string.
ASCII armor
Although principally used as a mechanism for text encoding of binary data, ASCII armoring is a programming and systems administration technique that also helps to avoid delimiter collision in some circumstances.[26][27] This technique is contrasted from the other approaches described above because it is more complicated, and therefore not suitable for small applications and simple data storage formats. The technique employs a special encoding scheme, such as base64, to ensure that delimiter or other significant characters do not appear in transmitted data. The purpose is to prevent multilayered escaping, i.e. for doublequotes.
This technique is used, for example, in Microsoft's ASP.NET web development technology, and is closely associated with the "VIEWSTATE" component of that system.[28]
Example
The following simplified example demonstrates how this technique works in practice.
The first code fragment shows a simple HTML tag in which the VIEWSTATE value contains characters that are incompatible with the delimiters of the HTML tag itself:
<input type="hidden" name="__VIEWSTATE" value="BookTitle:Nancy doesn't say "Hello World!" anymore." />
This first code fragment is not well-formed, and would therefore not work properly in a "real world" deployed system.
To store arbitrary text in an HTML attribute, HTML entities can be used. In this case """ stands in for the double-quote:
<input type="hidden" name="__VIEWSTATE" value="BookTitle:Nancy doesn't say "Hello World!" anymore." />
Alternatively, any encoding could be used that doesn't include characters that have special meaning in the context, such as base64:
<input type="hidden" name="__VIEWSTATE" value="Qm9va1RpdGxlOk5hbmN5IGRvZXNuJ3Qgc2F5ICJIZWxsbyBXb3JsZCEiIGFueW1vcmUu" />
Or percent-encoding:
<input type="hidden" name="__VIEWSTATE" value="BookTitle:Nancy%20doesn%27t%20say%20%22Hello%20World!%22%20anymore." />
This prevents delimiter collision and ensures that incompatible characters will not appear inside the HTML code, regardless of what characters appear in the original (decoded) text.[28]
See also
- CDATA
- Decimal separator
- Delimiter-separated values
- Escape sequence
- String literal
- Tab-separated values
References
- ^ "Definition: delimiter". Federal Standard 1037C - Telecommunications: Glossary of Telecommunication Terms. Archived from the original on 2013-03-05. Retrieved 2019-11-25.
- ^ "What is a Delimiter?". www.computerhope.com. Retrieved 2020-08-09.
- ^ Rohl, Jeffrey S. (1973). Programming in Fortran. Oxford Oxfordshire: Oxford University Press. ISBN 978-0-7190-0555-8. describing the method in Hollerith notation under the Fortran programming language.
- ^ a b de Moor, Georges J. (1993). Progress in Standardization in Health Care Informatics. IOS Press. ISBN 90-5199-114-2. p. 141
- ^ Friedl, Jeffrey E. F. (2002). Mastering Regular Expressions: Powerful Techniques for Perl and Other Tools. O'Reilly. ISBN 0-596-00289-0. p. 319
- ^ Scott, Michael Lee (1999). Programming Language Pragmatics. Morgan Kaufmann. ISBN 1-55860-442-1.
- ^ a b c Wall, Larry; Orwant, Jon (July 2000). Programming Perl (Third ed.). O'Reilly. ISBN 0-596-00027-8.
- ^ Kaufmann, Matt (2000). Computer-Aided Reasoning: An Approach. Springer. ISBN 0-7923-7744-3.p. 3
- ^ Meyer, Mark (2005). Explorations in Computer Science. Oxford Oxfordshire: Oxford University Press. ISBN 978-0-7637-3832-7. references C-style programming languages prominently featuring curly brackets and semicolons.
- ^ Dilligan, Robert (1998). Computing in the Web Age. Oxford Oxfordshire: Oxford University Press. ISBN 978-0-306-45972-6.Describes syntax and delimiters used in HTML.
- ^ a b Schwartz, Randal (2005). Learning Perl. Oxford Oxfordshire: Oxford University Press. ISBN 978-0-596-10105-3.Describes string literals.
- ^ Watt, Andrew (2003). Sams Teach Yourself Xml in 10 Minutes. Oxford Oxfordshire: Oxford University Press. ISBN 978-0-672-32471-0. Describes XML processing instruction. p. 21.
- ^ Cabrera, Harold (2002). C# for Java Programmers. Oxford Oxfordshire: Oxford University Press. ISBN 978-1-931836-54-8. Describes single-line and multi-line comments. p. 72.
- ^ "Jakarta Server Pages Specification, Version 4.0akarta Server Pages Specification, Version 4.0". GitHub. Retrieved 2023-02-10.
- ^ ISO/TC 97/SC 2 (December 1, 1975). The set of control characters for ISO 646 (PDF). ITSCJ/IPSJ. ISO-IR-1.
{{citation}}: CS1 maint: numeric names: authors list (link) - ^ American National Standards Institute (December 1, 1975). ASCII graphic character set (PDF). ITSCJ/IPSJ. ISO-IR-6.
- ^ Lewine, Donald (1991). Posix Programmer's Guide. Oxford Oxfordshire: Oxford University Press. ISBN 978-0-937175-73-6. Describes use of control-z. p. 156,
- ^ Friedl, Jeffrey (2006). Mastering Regular Expressions. Oxford Oxfordshire: Oxford University Press. ISBN 978-0-596-52812-6. describing solutions for embedded-delimiter problems p. 472.
- ^ Discussion on ASCII Delimited Text vs CSV and Tab Delimited
- ^ Kahrel, Peter (2006). Automating InDesign with Regular Expressions. O'Reilly. p. 11. ISBN 0-596-52937-6.
- ^ Yukihiro, Matsumoto (2001). Ruby in a Nutshell. O'Reilly. ISBN 0-596-00214-9. In Ruby, these are indicated as general delimited strings. p. 11
- ^ Network Protocols Handbook. Javvin Technologies Inc. 2005. ISBN 0-9740945-2-8. p. 26
- ^ Computational Linguistics and Intelligent Text Processing. Oxford Oxfordshire: Oxford University Press. 2001. ISBN 978-3-540-41687-6. Describes whitespace delimiters. p. 258.
- ^ Friedl, Jeffrey (2006). Mastering Regular Expressions. Oxford Oxfordshire: Oxford University Press. ISBN 978-0-596-52812-6. page 472.
- ^ Perl operators and precedence
- ^ Rhee, Man (2003). Internet Security: Cryptographic Principles, Algorithms and Protocols. John Wiley and Sons. ISBN 0-470-85285-2.(an example usage of ASCII armoring in encryption applications)
- ^ Gross, Christian (2005). Open Source for Windows Administrators. Charles River Media. ISBN 1-58450-347-5.(an example usage of ASCII armoring in encryption applications)
- ^ a b Kalani, Amit (2004). Developing and Implementing Web Applications with Visual C# . NET and Visual Studio . NET. Que. ISBN 0-7897-2901-6.(describes the use of Base64 encoding and VIEWSTATE inside HTML source code)
External links
This page was last edited on 26 March 2024, at 16:50