blocks|key|565850|text|整数存储为整数值，以二进制形式表示为1和0的单个集合，占用几个字节(取决于操作系统)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|565851|字符串以每数字一个字符的形式存储，每个字符都使用字节中的位模式。|565852|因此，在您的示例中，字符串占用的字节数量大约是ints的两倍。|565853|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

the integers are stored as integer values represented in binary as a single set of 1's and zeroes, taking up a couple bytes (depending on the OS)

the strings are stored as one character per digit, each one using a bit pattern in its byte. 

so in your example, the strings are taking up approximately twice the amount of bytes to represent as compared to the ints.

blocks|key|565855|text|通常，字符串或整数(以最简单的形式)按字节进行比较。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|565856|因此，对于int示例，它变成了单个CPU指令：|565857|cmp+a,+b|code-block|syntax|javascript|565858|它运行得相当快(假设32位ints，32位或更好的处理器)。这是一个适合CPU寄存器的单一比较。|565859|然而，字符串更复杂。最简单的情况是：|565860|foreach+(+character+c+in+string+a,+character+d+in+string+b+)
++++cmp+c,+d|565861|并且必须遍历整个字符串，一个字符一个字符。如果字符串的长度不同，则必须处理它(显然，ints都是相同大小的)。|565862|在一个更复杂的层次上，对于地区和不同的字符集，每个字符串字符可能是2-4字节，一些字符(带有重音等)可能比较相等，尽管有不同的字节值。涉及的处理和处理要多得多，而更多的工作几乎总是意味着速度较慢。|565863|确切的行为因地区、字符集和语言而异。有些语言(例如，C#)用长度存储字符串，而另一些语言(C)只存储一个字符数组。其他语言可能是为字符串处理而设计的，或者有经过优化的库来处理它，这样可以降低成本。|565864|有趣的是，在理论上，当使用ASCII字符串时，比较3个字符或更少的字符串可能与比较ints一样快。在这种情况下，它更多地与所涉及的内存量有关(strcmp+for+ASCII可以在内部使用memcmp，这几乎是==将使用的)。对于在开头存储字符串长度和0长度(空)字符串的语言来说，这也是正确的，因为它们可以简单地比较长度(可能是int)。|offset|length|style|CODE|565865|entityMap^0|0|0|0|0|0|0|0|0|0|1Z|6|2M|6|2X|2|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|17|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1A|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1B|8|@$W|1C|X|1D|Y|Z]|$W|1E|X|1F|Y|Z]|$W|1G|X|1H|Y|Z]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|11|$]]

Typically, the string or integer (in the simplest form) is compared byte by byte. 

So for the int example, that becomes the single CPU instruction:

<pre><code>cmp a, b
</code></pre>

Which runs rather fast (assuming 32-bit ints, 32-bit or better processor). It's a single comparison that fits in CPU registers.

Strings, however, are more complex. At their simplest, it looks like:

<pre><code>foreach ( character c in string a, character d in string b )
 cmp c, d
</code></pre>

and has to loop over the entire string, character by character. If the strings are of different lengths, it has to handle that (ints are both of the same size, obviously).

At a more complex level, with locale and various character sets, each string character may be 2-4 bytes and some characters (with accents and such) may compare as equal to each other despite having different byte values. Far more handling and processing is involved, and more work almost always means slower.

The exact behavior varies by locale, character set, and language. Some languages (C#, for example) store strings with a length, while others (C) simply store an array of characters. Other languages may be designed for string processing or have optimized libraries to handle it, which can decrease the cost.

Interestingly, in theory, when working with ASCII strings, comparing strings of 3 characters or less could be roughly as fast as comparing ints. In that case, it has more to do with the amount of memory involved (<code>strcmp</code> for ASCII can use <code>memcmp</code> internally, which is approximately what <code>==</code> would use anyway). This may also hold true for languages which store the string length at the beginning and 0-length (empty) strings, as they can simply compare the length (which may be an int).

How are integers and strings compared at a low level? Like whenever we use 

<pre><code>int a = 11;
int b = 12;

compare(a,b); //Just an example comparison, not in any particular language.
</code></pre>

And 

<pre><code>String a = "11";
String b = "12";

compare(a,b);
</code></pre>

Now what I am asking is what is the system level difference between these two comparisons?Question is not for any particular language, it's just a generic issue. It is also not regarding the string to integer conversion/comparison or vice-versa. I know that the answers might be different for different platforms and different languages, but as I have no clue about this I am just asking a generic question.

And why are integer comparisons always considered faster then string comparisons?

integer and string comparison at system level

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

低水平的整数和字符串是如何比较的？就像我们每次使用int a = 11;int b = 12;compare(a,b); //Just an example comparison, not in any particular language.和String a = "11";String b = "12";compa...

问系统级的整数和字符串比较
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问系统级的整数和字符串比较EN