String comparison: Difference between revisions

 

The task should demonstrate:

* How to achieve both case sensitive comparisons and case insensitive comparisons within the language

* How the language handles comparison of numeric strings if these are not treated lexically

 

<br>

 

 

<br><br>

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program comparString64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

=={{header|Ada}}==

Ada uses the usual comparison operators ("=" for equality, "/=" for not being equal, etc.) for strings. One uses the same comparison operators to compare variables of other types (integers, floating point numbers, etc.).

String comparisons are case sensitive. Case insensitive comparisons have to use some conversion operation, such as Ada.Characters.Handling.To_Lower from the standard library, cf. [[http://rosettacode.org/wiki/String_case#Ada]]

 

 

procedure String_Compare is

Print_Comparison ("the", "there");

Print_Comparison ("there", "the");

 

{{out}}

 

=={{header|Aime}}==

 

s = "occidental";

 

# case insensitive comparison

{{out}}

<pre>occidental vs oriental (==, !=, <, <=, >=, >): 0 -15 1 1 0 0

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}

 

# when comparing strings, Algol 68 ignores trailing blanks #

test( a >= b, "a >= b" );

 

{{out}}

<pre>

 

=={{header|ALGOL W}}==

string(10) a;

string(12) b;

% there are no other forms of string comparison builtin to Algol W %

 

{{out}}

<pre>

Comparisons can be done also using the equals(), equalsIgnoreCase() and compareTo() methods.

 

{

/**

System.debug('The lexical relationship is: ' + A.compareTo(B));

}

 

{{Out}}

 

=={{header|AppleScript}}==

set s1 to "this"

set s2 to "that"

if int1 < s1 then

-- comparison is numeric

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program comparString.s */

bx lr /* end procedure */

 

 

=={{header|Astro}}==

print("\n$a is of type ${typeof(a)} and $b is of type ${typeof(b)}")

if a < b: print("$a is strictly less than $b")

compare(24, 123)

compare(5.0, 5)

 

=={{header|Avail}}==

[

a : string,

// Case-insensitive comparison requires a manual case conversion

Print: "a & b are equal case-insensitively?" ++ “lowercase a = lowercase b”;

Avail is strongly-typed and the standard library's comparison functions do not admit mixed comparison between numerics and strings. Strings are immutable tuples of characters and are always compared by value -- few entities in Avail have identity so "object equality" is usually meaningless.

 

=={{header|AWK}}==

The behaviour of the operators when one value is considered to be numeric (eg. from the input source), but the other value has been defined explicitly as a numeric string by using doublequote enclosures may also vary depending on which awk interpreter is being used.

 

a="BALL"

b="BELL"

if (tolower(a) == tolower(b)) { print "The first and second string are the same disregarding letter case" }

 

 

=={{header|BASIC}}==

20 LET B$="BELT"

30 IF A$ = B$ THEN PRINT "THE STRINGS ARE EQUAL": REM TEST FOR EQUALITY

70 IF A$ <= B$ THEN PRINT A$;" IS NOT LEXICALLY HIGHER THAN ";B$

80 IF A$ >= B$ THEN PRINT A$;" IS NOT LEXICALLY LOWER THAN ";B$

 

On a platform that supports both uppercase and lowercase characters, the string comparitive operators are case sensitive. To perform case insensitive matching, make sure both strings are converted to the same lettercase. Here we assume that the BASIC has the UPPER$ and LOWER$ keyword pair for case conversion. If not, then some number crunching based on the character codes is required. (In Ascii add 32 to uppercase letter codes to get the lowercase equivalent). Note that any whitespace within the strings must also match exactly for the strings to be considered equal.

 

20 LET B$="belt"

 

==={{header|Applesoft BASIC}}===

Applesoft BASIC does not have a built in UPPER$ function.

 

shav$ = "Shaw, George Bernard"

shakes$ = "Shakespeare, William"

IF ASC(MID$(s$, i%, 1)) >= ASC "a" AND ASC(MID$(s$, i%, 1)) <= ASC "z" THEN ns$ += CHR$(ASC(MID$(s$, i%, 1)) - &20) ELSE ns$ += MID$(s$, i%, 1)

NEXT

{{out}}

<pre>The two strings are not equal

Shaw, George Bernard is not lexically lower than Shakespeare, William

The two strings are not equal (even disregarding case)</pre>

 

=={{header|Bracmat}}==

String comparison in Bracmat is performed by string pattern matching using an atomic pattern. Bracmat has two pattern matching regimes. Originally, pattern matching was only done on tree structures, with patterns mimicking the subject tree to match. Later string pattern matching was introduced. String pattern matching is discernible from the original pattern matching by the prefix <code>@</code>. String pattern matching requires that the subject is atomic. Patterns for string matching can be as complex as patterns used for matching structures. String comparison is a very simple string pattern matching operation requiring just an atomic pattern, combined with some prefixes if needed.

The atomic pattern can be prefixed with <code>&lt;</code> (less than), <code>&gt;</code> (greater than), <code>~</code> (not) or <code>%</code> (coerces string matching) or combinations thereof. If both sides of the match operator <code>:</code> are numbers, Bracmat does a numerice comparison, unless the pattern (the rhs) has the prefix <code>%</code>.

& ( ( @(abc:abc)

& @(123:%123)

)

& done

 

=={{header|Burlesque}}==

 

blsq ) "abc""abc"==

1

blsq ) "ABC""Abc"cm

-1

 

''cm'' is used for comparision which returns 1,0,-1 like C's strcmp. ''=='' is Equal and ''!='' is NotEqual.

'''Solution'''

C provides the strcmp and strcasecmp functions for lexical comparison of ASCIIz strings, with declarations found in string.h . strcmp causes a good deal of confusion because it returns 0 when the strings are equal. Hence the likely looking common mistake

/* WRONG! */

if (strcmp(a,b)) action_on_equality();

Wrapping strcmp with macros or functions makes good sense. c has other functions to compare binary data, version strings, wide character strings, and strings in current locale. These behave similarly.

/*

compilation and test in bash

return 0;

}

 

=={{header|C++}}==

#include <iostream>

#include <sstream>

demo_compare<double>(numA, numB, "numerically");

return (a == b);

{{out}}

<pre>1.2.Foo and 1.3.Bar are not exactly lexically equal.

=={{header|Clipper}}==

We will compare two strings, ''s1'' and ''s2''. The following comparisons are case sensitive.

? "The strings are equal"

ENDIF

IF s1 < s2

? "s2 is lexically ordered after than s1"

To achieve case insensitive comparisons, we should use Upper() or Lower() functions:

? "The strings are equal"

ENDIF

 

=={{header|COBOL}}==

Strings can be compared using the normal conditional syntax, like so:

"helloo" <> "hello" *> inequality

 

COBOL 2002 introduced the intrinsic functions <code>LOCALE-COMPARE</code> and <code>STANDARD-COMPARE</code>, which return one of the strings <code>"="</code>, <code>">"</code> or <code>"<"</code> depending on their parameters.

FUNCTION STANDARD-COMPARE("aello", "hello") *> "<"

 

Trailing spaces in strings are removed when strings are compared. However, if the strings are then of unequal length, then the shorter string is padded with spaces.

 

=={{header|ColdFusion}}==

===In CFML===

 

<cfargument name="String1" type="string">

<cfargument name="String2" type="string">

</cfif>

<cfreturn VARIABLES.Result >

 

===In CFScript===

 

function CompareString( String1, String2 ) {

VARIABLES.Result = "";

return VARIABLES.Result;

}

 

=={{header|Common Lisp}}==

 

Case-sensitive comparison functions:

T

> (string= "foo" "FOO")

NIL

> (string<= "FOo" "Foo")

 

Case-insensitive comparison functions:

T

> (string-not-equal "foo" "FOO")

3

> (string-not-lessp "baz" "bAr")

 

Numeric strings are always compared lexically:

0

> (string> "45" "9")

 

=={{header|Component Pascal}}==

BlackBox Component Builder

IMPORT StdLog,Strings;

 

END Do;

 

Execute: ^Q StringComparision.Do<br/>

Output:

=={{header|D}}==

See also [[Empty_string]]

 

void main() {

assert(s.icmp("ABCD") == 0); // case insensitive

assert(s.cmp("ABCD") == 1); // case sensitive

 

=={{header|Dyalect}}==

{{trans|Swift}}

 

if a == b {

print("'\(a)' and '\(b)' are lexically equal.")

}

}

{{Out}}

<pre>'cat' and 'dog' are not lexically equal.

'cat' is lexically before 'dog'.

'cat' is not lexically after 'dog'.

</pre>

 

=={{header|Elena}}==

ELENA 4.x:

compareStrings = (val1,val2)

console.readChar()

 

=={{header|Elixir}}==

s == "abcd" #=> true

s == "abce" #=> false

s < "abce" #=> true

s >= "abce" #=> false

 

=={{header|Erlang}}==

Examples from Erlang shell:

 

10> V = "abcd".

"abcd"

16> string:to_lower(V) =:= string:to_lower("ABCD").

true

 

=={{header|F_Sharp|F#}}==

[http://msdn.microsoft.com/en-us/library/system.stringcomparison StringComparison] enumeration value how to compare, which might be "culture sensitive" or use an "ordinal comparison".

Both of these might also be of the <tt>IgnoreCase</tt> variant.

 

// self defined operators for case insensitive comparison

compare "24" "123"

compare "BELL" "bELL"

Output

<pre style="font-size:smaller">YUP is less than or equal to YUP

Strings in Factor are just sequences of unicode code points, so the usual sequence operations apply to strings. The <tt><=></tt> word from the <tt>math.order</tt> vocabulary can be used to lexically compare strings, and Factor includes the <tt>human<=></tt> word in the <tt>sorting.human</tt> vocabulary for comparing numeric strings like a human would.

 

 

IN: scratchpad "foo" "bar" = . ! compare for equality

+gt+

IN: scratchpad "a1" "a03" human<=> . ! comparing numeric strings like a human

 

=={{header|Falcon}}==

'''VBA/Python programmer's approach. I'm just a junior Falconeer but this code seems to go the falcon way''

/* created by Aykayayciti Earl Lamont Montgomery

April 9th, 2018 */

result = NumCompare(num1, num2)

> @ "$num1 $result $num2"

{{out}}

<pre>

The ANS Forth standard has the word COMPARE to lexically compare two strings, with the same behavior as the C standard library strcmp() function.

 

: str-neq ( str len str len -- ? ) compare 0<> ;

: str-lt ( str len str len -- ? ) compare 0< ;

: str-gt ( str len str len -- ? ) compare 0> ;

: str-le ( str len str len -- ? ) compare 0<= ;

 

Although many Forths allow case-insensitive lookup of ASCII dictionary names for function and variable names (FIND, SEARCH-WORDLIST), this capability is not exposed for other uses in a standard way.

 

=={{header|Fortran}}==

 

Fortran IV introduced the A''w'' format code, where ''w'' was an integer such as one or two, and this transferred the bit pattern "as is" to or from a variable in a READ or WRITE statement. A sixteen-bit integer would suit either A1 or A2, a thirty-two bit floating-point variable could hold up to four eight-bit character codes, and so on, though with caution because some computers had eighteen-bit words and others forty-eight bit words, not just powers of two. An array of integers might be used to hold a line of text, and A1 format (one character per integer) would be easier for manipulation, while A2 would use less storage. The variables could be compared as numerical values and so string comparison was possible. However, the numerical values would be quite strange, because A1 format would place the bit pattern at the high-order end of the word (where the sign bit would be found in integers), and with floating-point variables the resulting values would be even more surprising. On the B6700, the high-order bit of a 48-bit word was not employed in arithmetic at all. Even so, in this period, interpreters for SNOBOL (surely the epitome of string-manipulation languages) were often written in Fortran, because of its portability. So, string comparison in the same way as number comparison.

 

=={{header|FreeBASIC}}==

 

' Strings in FB natively support the relational operators which compare lexically on a case-sensitive basis.

Print

Print "Press any key to quit"

 

{{out}}

Dog is equal to dog if case is ignored

Dog is not equal to Pig

</pre>

 

=={{header|Go}}==

 

import (

// for Unicode normalization, collation tables, and locale sensitive

// comparisons.

{{out}}

<pre>

=={{header|Harbour}}==

We will compare two strings, ''s1'' and ''s2''. The following comparisons are case sensitive.

? "The strings are equal"

ENDIF

IF s1 < s2

? "s2 is lexically ordered after than s1"

To achieve case insensitive comparisons, we should use Upper() or Lower() functions:

? "The strings are equal"

 

=={{header|Haskell}}==

Examples from the Haskell shell:

> "abc" == "abc"

True

> map toLower "HELLOWORLD" == map toLower "HelloWorld"

True

 

=={{header|Icon}} and {{header|Unicon}}==

Same in both languages.

 

s1 := A[1] | "a"

s2 := A[2] | "b"

"123" >> 12 # Lexical comparison (12 coerced into "12")

"123" > 12 # Numeric comparison ("123" coerced into 123)

 

=={{header|J}}==

'''Solution:'''

The primitive <code>-:</code> can be used to determine whether two strings are equivalent, but J doesn't have other inbuilt lexical comparison operators. They can defined as follows:

ne=: -.@-: NB. not equal

gt=: {.@/:@,&boxopen *. ne NB. lexically greater than

lt=: -.@{.@/:@,&boxopen *. ne NB. lexically less than

ge=: {.@/:@,&boxopen +. eq NB. lexically greater than or equal to

 

'''Usage:'''

0 1 0 1 0 1

'ball' (eq , ne , gt , lt , ge , le) 'ball'

1 0 0 0 1 1

'YUP' (eq , ne , gt , lt , ge , le) 'YEP'

 

=={{header|Java}}==

A String object in Java represents a UTF-16 string.

Comparisons are done using the equals(), equalsIgnoreCase(), compareTo(), and compareToIgnoreCase() methods.

{

public static void main (String[] args)

System.out.printf("The case-insensitive lexical relationship is: %d\n\n", A.compareToIgnoreCase(B));

}

{{Out}}

<pre>'Hello' and 'Hello' are lexically equal.

The lexical relationship is: -1

The case-insensitive lexical relationship is: 0</pre>

 

=={{header|jq}}==

 

"this" == "this" # true

"this" == "This" # false

"beta" < "alpha" # false

 

With the caveat that these are what they are, case-insensitive comparisons can be achieved as illustrated by this example:

 

 

=={{header|Julia}}==

* Julia can handle both ASCII and non-ASCII chars;

{{trans|Python}}

println("\n$a is of type $(typeof(a)) and $b is of type $(typeof(b))")

if a < b println("$a is strictly less than $b") end

compare("24", "123")

compare(24, 123)

 

{{out}}

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

println("kotlin comes before Kotlin = ${k1 < k2.toLowerCase()}")

println("kotlin comes after Kotlin = ${k1 > k2.toLowerCase()}")

 

{{out}}

 

=={{header|Lasso}}==

"'this' == 'this': " + ('this' == 'this') // true

"'this' == 'This': " + ('this' == 'This') // true, as it's case insensitive

"'The quick brown fox jumps over the rhino'->endswith('rhino'): " +

('The quick brown fox jumps over the rhino'->endswith('rhino')) // true

 

{{out}}

=={{header|Lingo}}==

Lingo's built-in string comparison is case-insensitive:

-- 1

 

 

put "abc">"def"

 

Case-sensitive string comparison could be implemented e.g. like this:

-- Returns 1 if str1 is greater than str2

-- Returns 0 if str1 and str2 are equal

else if h1>h2 then return 1

return 0

 

=={{header|Lua}}==

* Case-insensitivity can be accomplished by using <code>string.upper</code> or <code>string.lower</code> on both strings prior to comparing them.

* Lua does not have a dedicated identity operator as == already plays that role. If two strings have equal contents, they are the same object and therefore equal.

print(("%s is of type %s and %s is of type %s"):format(

a, type(a),

compare('24', '123')

compare(24, 123)

 

{{out}}

</pre>

 

If[x == y,

Print["Comparing for equality (case sensitive): " <> x <> " and " <> y <> " ARE equal"],

compare["Hello", "Hello"]

compare["3.1", "3.14159"]

{{out}}

<pre>Comparing for equality (case sensitive): Hello and Hello ARE equal

Comparing for order (case sensitive): mathematica comes before Mathematica

Comparing for equality (case insensitive): mathematica and Mathematica ARE equal</pre>

 

=={{header|MiniScript}}==

string2 = input("Please enter a second string.")

 

if string1.lower != string2.lower then

print "Strings are NOT equal. (case insensitive)"

 

=={{header|Nanoquery}}==

{{trans|Python}}

While many comparisons in Nanoquery yield the same results as Python, numeric strings are coerced into numeric types, so comparison between numeric strings yields the same results as the equivalent numeric types.

println format("\n%s is of type %s and %s is of type %s", a, type(a), b, type(b))

if a < b

compare("24", "123")

compare(24, 123)

 

{{out}}

 

 

if animal = 'cat' then

say animal "is lexically equal to cat"

if ' cat ' == 'cat' then

say "this will not print because comparison is strict"

The list of strict comparison operators described in the [[#REXX|REXX]] sample apply to [[NetRexx]] too.

 

=={{header|Nim}}==

 

var s1: string = "The quick brown"

echo(">= : ", s1 >= s2)

# cmpIgnoreCase(a, b) => 0 if a == b; < 0 if a < b; > 0 if a > b

{{out}}

<pre>== : false

=={{header|Oforth}}==

 

"abcd" "abce" <>

"abcd" "abceed" <=

"abce" "abcd" >

 

=={{header|ooRexx}}==

 

There is a way to "caseless" compare array elements:

a~sortwith(.caselesscomparator~new)

Do i=1 To 5

Say a[i]

Output:

<pre>A 1

Scalar variables are weakly typed in Perl, and there are two sets of comparison operators that can be used on them: One set for (coercive) numeric comparison, and one set for (coercive) lexical string comparison. The second set is demonstrated in the following:

 

# With older Perl versions you can use lc() as a poor-man's substitute.

 

compare('Hello', 'Hello');

compare('5', '5.0');

 

{{out}}

 

=={{header|Phix}}==

 

=={{header|PicoLisp}}==

str= =

str< <

(str< "12" "45") )

 

=={{header|PowerShell}}==

"a" -lt "b" # lower than

"a" -eq "b" # equal

"a" -ne "b" # not equal

"a" -ge "b" # greater than or equal

<b>Output:</b>

<pre>

By default operators are case insensitive.

Preceed them by the letter "c" to make them case sensitive like this:

"a" -eq "A"

"a" -ceq "A"

<pre>

True

 

=={{header|PureBasic}}==

Print("Test "+Check+#TAB$)

If tof=1 : PrintN("true") : Else : PrintN("false") : EndIf

Compare(a$,b$,1,1)

Input()

{{out}}

<pre>

* Python is strongly typed. The string '24' is never coerced to a number, (or vice versa).

* Python does not have case-insensitive string comparison operators, instead use <code>name.upper()</code> or <code>name.lower()</code> to coerce strings to the same case and compare the results.

print("\n%r is of type %r and %r is of type %r"

% (a, type(a), b, type(b)))

compare('24', '123')

compare(24, 123)

 

{{out}}

5.0 is equal to 5

5.0 has negated object identity with 5</pre>

 

=={{header|R}}==

{{trans|Python}}

{

cat(paste(a, "is of type", class(a), "and", b, "is of type", class(b), "\n"))

compare('24', '123')

compare(24, 123)

 

{{out}}

 

And a more ridiculous version:

{

cat(paste(a, "is of type", class(a), "and", b, "is of type", class(b), "\n"))

invisible()

 

=={{header|Racket}}==

 

#lang racket

 

;; How to achieve both case sensitive comparisons and case insensitive comparisons within the language

(string-ci=? "foo" "FOO")

 

=={{header|Raku}}==

 

String comparisons never do case folding because that's a very complicated subject in the modern world of Unicode. (You can explicitly apply an appropriate case-folding function to the arguments before doing the comparison, or for "equality" testing you can do matching with a case-insensitive regex, assuming Unicode's language-neutral case-folding rules are okay.)

my $A = "{$a.WHAT.^name} '$a'";

my $B = "{$b.WHAT.^name} '$b'";

compare 24, 123;

compare 5.1, 5;

{{out}}

<pre>Str 'YUP' and Str 'YUP' are lexically equal

The generic relationship of Num '5.1' and Rat '5.1' is Same

The numeric relationship of Num '5.1' and Rat '5.1' is Same</pre>

 

=={{header|REXX}}==

Note that some REXXes can use (support) characters other than a backslash &nbsp; ['''\'''] &nbsp; for a logical not &nbsp; ['''¬'''].

<br>Still other REXX support the use of a tilde &nbsp; ['''~'''] &nbsp; for a logical not.

say 'This is an ' word('ASCII EBCDIC', 1+(1=='f1')) ' system.'

say

caselessComp: procedure; arg a,b /*ARG uppercases the A & B args.*/

return a==b /*if exactly equal, return 1. */

Programming note:

 

(a) if both operands are NUMBERS (normal, non-strict) comparisons will always be done arithmetically.

<br>(b) to implement caseless comparison one can proceed as follows:

* 16.05.2013 Walter Pachl

**********************************************************************/

Return res

 

Output:

<pre>"A" < "a" -> 0

 

=={{header|Ring}}==

 

if s1 = s2

ok

 

 

=={{header|Robotic}}==

There is no opposite of the case-sensitive comparison.

 

set "$str1" to "annoy"

set "$str2" to "annoy"

* "&$str1& is lexicographically less than &$str2&"

end

 

=={{header|Ruby}}==

[["YUP", "YUP"], ["YUP", "Yup"], ["bot","bat"], ["aaa", "zz"]].each do |str1, str2|

method_names.each{|m| puts "%s %s %s\t%s" % [str1, m, str2, str1.send(m, str2)]}

puts

{{output}}

<pre>

 

=={{header|Run BASIC}}==

b$ = "cat"

if a$ = b$ then print "the strings are equal" ' test for equalitY

if a$ <= b$ then print a$;" is not lexicallY higher than ";b$

if a$ >= b$ then print a$;" is not lexicallY lower than ";b$

 

=={{header|Rust}}==

Comparisons are case sensitive by default, all (Ascii) uppercase letters are treated as lexically before all lowercase letters.

For case-insensitive comparisons, use Ascii Extensions. In general, case is not a concept that applies to all unicode symbols.

 

fn main() {

 

// repeat checks

 

{{out}}

 

=={{header|Scala}}==

def compare(a: String, b: String) {

if (a == b) println(s"'$a' and '$b' are lexically equal.")

compare("ĴÃVÁ", "ĴÃVÁ")

compare("ĴÃVÁ", "ĵãvá")

{{out}}

<pre>'Hello' and 'Hello' are lexically equal.

 

=={{header|Scheme}}==

;; Comparing two strings for exact equality

(string=? "hello" "hello")

;; case insensitive comparison

 

=={{header|Seed7}}==

[http://seed7.sourceforge.net/libraries/string.htm#lower%28in_string%29 lower] can be used to do an insensitive comparison.

 

 

const proc: showComparisons (in string: a, in string: b) is func

showComparisons("the", "there");

showComparisons("there", "the");

 

The function below compares strings, which may contain digit sequences. The digit sequences are compared numerically.

 

 

const func integer: cmpNumeric (in var string: stri1, in var string: stri2) is func

end if;

end while;

 

Original source: [http://seed7.sourceforge.net/algorith/string.htm#cmpNumeric]

=={{header|Sidef}}==

{{trans|Ruby}}

for s1, s2 in [<YUP YUP>,<YUP Yup>,<bot bat>,<aaa zz>] {

methods.each{|m| "%s %s %s\t%s\n".printf(s1, m, s2, s1.(m)(s2))}

print "\n"

 

=={{header|SNOBOL4}}==

s2 = 'mnopqrs'

s3 = 'mnopqr'

OUTPUT = GT('1234', 1233) '"1234" is greater than 1233 (numeric comparison).'

OUTPUT = LT('1233', 1234) '"1233" is less than 1234 (numeric comparison).'

{{out}}

<pre>

 

=={{header|Standard ML}}==

("one","two"),

("one","Two"),

"one" <> "two" ;

val it = true: bool

 

=={{header|Swift}}==

if a == b {

println("'\(a)' and '\(b)' are lexically equal.")

}

}

{{Out}}

<pre>

'cat' is not lexically after 'dog'.

</pre>

 

=={{header|Tcl}}==

The best way to compare two strings in Tcl for equality is with the <code>eq</code> and <code>ne</code> expression operators:

puts "the strings are equal"

}

if {$a ne $b} {

puts "the strings are not equal"

The numeric <code>==</code> and <code>!=</code> operators also mostly work, but can give somewhat unexpected results when the both the values ''look'' numeric. The <code>string equal</code> command is equally suited to equality-testing (and generates the same bytecode).

 

For ordering, the <code>&lt;</code> and <code>&gt;</code> operators may be used, but again they are principally numeric operators. For guaranteed string ordering, the result of the <code>string compare</code> command should be used instead (which uses the unicode codepoints of the string):

puts "first string lower than second"

}

if {[string compare $a $b] > 0} {

puts "first string higher than second"

Greater-or-equal and less-or-equal operations can be done by changing what exact comparison is used on the result of the <code>string compare</code>.

 

Tcl also can do a prefix-equal (approximately the same as <code>strncmp()</code> in [[C]]) through the use of the <tt>-length</tt> option:

puts "first three characters are equal"

And case-insensitive equality is (orthogonally) enabled through the <tt>-nocase</tt> option. These options are supported by both <code>string equal</code> and <code>string compare</code>, but not by the expression operators.

 

Traditional bourne shell (which used the 'test' command for comparisons) had no way of doing lexical comparisons.

 

 

A=Bell

# 0 , -0 , 0.0 and 00 are all lexically different if tested using the above methods.

 

 

Bash and other POSIX shells do support lexical comparisons:

 

#!/bin/bash

 

compare 24 123

compare 50 20

 

{{out}}

=={{header|Vala}}==

{{trans|Nim}}

var s1 = "The quick brown";

var s2 = "The Quick Brown";

stdout.printf("> : %s\n", s1 > s2 ? "true" : "false");

stdout.printf(">= : %s\n", s1 >= s2 ? "true" : "false");

 

{{out}}

> : true

>= : true

</pre>

 

=={{header|WDTE}}==

== 'example1' 'example2' -> ! -- io.writeln io.stdout; # Test for inequality.

< 'example1' 'example2' -- io.writeln io.stdout; # Test for lexical before.

 

# This is false. Strings are not coerced to numbers and vice-versa.

 

=={{header|zkl}}==

"foo" == "FOO" //False

"foo" == "foobar" //False

123<"123" //False, int on left forces "123".toInt()

123<"1234" //True