| [ < ] | [ > ] | [ << ] | [Plus haut] | [ >> ] | [Top] | [Table des matières] | [Index] | [ ? ] |
This function returns t if the arguments represent the same
character, nil otherwise. This function ignores differences in case
if case-fold-search is non-nil.
(char-equal ?x ?x)
⇒ t
(let ((case-fold-search nil))
(char-equal ?x ?X))
⇒ nil
|
This function returns t if the characters of the two strings match
exactly. Symbols are also allowed as arguments, in which case their print
names are used. Case is always significant, regardless of
case-fold-search.
(string= "abc" "abc")
⇒ t
(string= "abc" "ABC")
⇒ nil
(string= "ab" "ABC")
⇒ nil
|
The function string= ignores the text properties of the two strings.
When equal (voir la section Equality Predicates) compares two strings, it
uses string=.
For technical reasons, a unibyte and a multibyte string are equal if
and only if they contain the same sequence of character codes and all these
codes are either in the range 0 through 127 (ASCII) or 160 through
255 (eight-bit-graphic). However, when a unibyte string gets
converted to a multibyte string, all characters with codes in the range 160
through 255 get converted to characters with higher codes, whereas
ASCII characters remain unchanged. Thus, a unibyte string and its
conversion to multibyte are only equal if the string is all
ASCII. Character codes 160 through 255 are not entirely proper in
multibyte text, even though they can occur. As a consequence, the situation
where a unibyte and a multibyte string are equal without both being
all ASCII is a technical oddity that very few Emacs Lisp
programmers ever get confronted with. Voir la section Text Representations.
string-equal is another name for string=.
This function compares two strings a character at a time. It scans both the
strings at the same time to find the first pair of corresponding characters
that do not match. If the lesser character of these two is the character
from string1, then string1 is less, and this function returns
t. If the lesser character is the one from string2, then
string1 is greater, and this function returns nil. If the two
strings match entirely, the value is nil.
Pairs of characters are compared according to their character codes. Keep in mind that lower case letters have higher numeric values in the ASCII character set than their upper case counterparts; digits and many punctuation characters have a lower numeric value than upper case letters. An ASCII character is less than any non-ASCII character; a unibyte non-ASCII character is always less than any multibyte non-ASCII character (voir la section Text Representations).
(string< "abc" "abd")
⇒ t
(string< "abd" "abc")
⇒ nil
(string< "123" "abc")
⇒ t
|
When the strings have different lengths, and they match up to the length of
string1, then the result is t. If they match up to the length
of string2, the result is nil. A string of no characters is
less than any other string.
(string< "" "abc")
⇒ t
(string< "ab" "abc")
⇒ t
(string< "abc" "")
⇒ nil
(string< "abc" "ab")
⇒ nil
(string< "" "")
⇒ nil
|
Symbols are also allowed as arguments, in which case their print names are used.
string-lessp is another name for string<.
This function compares the specified part of string1 with the
specified part of string2. The specified part of string1 runs
from index start1 up to index end1 (nil means the end of
the string). The specified part of string2 runs from index
start2 up to index end2 (nil means the end of the
string).
The strings are both converted to multibyte for the comparison (voir la section Text Representations) so that a unibyte string and its conversion to multibyte
are always regarded as equal. If ignore-case is non-nil, then
case is ignored, so that upper case letters can be equal to lower case
letters.
If the specified portions of the two strings match, the value is t.
Otherwise, the value is an integer which indicates how many leading
characters agree, and which string is less. Its absolute value is one plus
the number of characters that agree at the beginning of the two strings.
The sign is negative if string1 (or its specified portion) is less.
This function works like assoc, except that key must be a
string or symbol, and comparison is done using compare-strings.
Symbols are converted to strings before testing. If case-fold is
non-nil, it ignores case differences. Unlike assoc, this
function can also match elements of the alist that are strings or symbols
rather than conses. In particular, alist can be a list of strings or
symbols rather than an actual alist. Voir la section Association Lists.
See also the compare-buffer-substrings function in Comparing Text, for a way to compare text in buffers. The function
string-match, which matches a regular expression against a string,
can be used for a kind of string comparison; see Regular Expression Searching.
| [ < ] | [ > ] | [ << ] | [Plus haut] | [ >> ] | [Top] | [Table des matières] | [Index] | [ ? ] |
Ce document a été généré par Eric Reinbold le 13 Octobre 2007 en utilisant texi2html 1.78.