godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2026-01-04 10:09:56 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/zh_Hant/class_int.rst

783 lines
30 KiB
ReStructuredText
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

:github_url: hide
.. _class_int:
int
===
整數內建型別。
.. rst-class:: classref-introduction-group
說明
----
Signed 64-bit integer type. This means that it can take values from ``-2^63`` to ``2^63 - 1``, i.e. from ``-9223372036854775808`` to ``9223372036854775807``. When it exceeds these bounds, it will wrap around.
\ **int**\ s can be automatically converted to :ref:`float<class_float>`\ s when necessary, for example when passing them as arguments in functions. The :ref:`float<class_float>` will be as close to the original integer as possible.
Likewise, :ref:`float<class_float>`\ s can be automatically converted into **int**\ s. This will truncate the :ref:`float<class_float>`, discarding anything after the floating-point.
\ **Note:** In a boolean context, an **int** will evaluate to ``false`` if it equals ``0``, and to ``true`` otherwise.
.. tabs::
.. code-tab:: gdscript
var x: int = 1 # x is 1
x = 4.2 # x is 4, because 4.2 gets truncated
var max_int = 9223372036854775807 # Biggest value an int can store
max_int += 1 # max_int is -9223372036854775808, because it wrapped around
.. code-tab:: csharp
int x = 1; // x is 1
x = (int)4.2; // x is 4, because 4.2 gets truncated
// We use long below, because GDScript's int is 64-bit while C#'s int is 32-bit.
long maxLong = 9223372036854775807; // Biggest value a long can store
maxLong++; // maxLong is now -9223372036854775808, because it wrapped around.
// Alternatively with C#'s 32-bit int type, which has a smaller maximum value.
int maxInt = 2147483647; // Biggest value an int can store
maxInt++; // maxInt is now -2147483648, because it wrapped around
You can use the ``0b`` literal for binary representation, the ``0x`` literal for hexadecimal representation, and the ``_`` symbol to separate long numbers and improve readability.
.. tabs::
.. code-tab:: gdscript
var x = 0b1001 # x is 9
var y = 0xF5 # y is 245
var z = 10_000_000 # z is 10000000
.. code-tab:: csharp
int x = 0b1001; // x is 9
int y = 0xF5; // y is 245
int z = 10_000_000; // z is 10000000
.. rst-class:: classref-reftable-group
建構子
------
.. table::
:widths: auto
+-----------------------+---------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`int<class_int_constructor_int>`\ (\ ) |
+-----------------------+---------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`int<class_int_constructor_int>`\ (\ from\: :ref:`int<class_int>`\ ) |
+-----------------------+---------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`int<class_int_constructor_int>`\ (\ from\: :ref:`String<class_String>`\ ) |
+-----------------------+---------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`int<class_int_constructor_int>`\ (\ from\: :ref:`bool<class_bool>`\ ) |
+-----------------------+---------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`int<class_int_constructor_int>`\ (\ from\: :ref:`float<class_float>`\ ) |
+-----------------------+---------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
運算子
------
.. table::
:widths: auto
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator !=<class_int_operator_neq_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator !=<class_int_operator_neq_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`operator %<class_int_operator_mod_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`operator &<class_int_operator_bwand_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`Color<class_Color>` | :ref:`operator *<class_int_operator_mul_Color>`\ (\ right\: :ref:`Color<class_Color>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`Quaternion<class_Quaternion>` | :ref:`operator *<class_int_operator_mul_Quaternion>`\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`Vector2<class_Vector2>` | :ref:`operator *<class_int_operator_mul_Vector2>`\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`Vector2i<class_Vector2i>` | :ref:`operator *<class_int_operator_mul_Vector2i>`\ (\ right\: :ref:`Vector2i<class_Vector2i>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`Vector3<class_Vector3>` | :ref:`operator *<class_int_operator_mul_Vector3>`\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`Vector3i<class_Vector3i>` | :ref:`operator *<class_int_operator_mul_Vector3i>`\ (\ right\: :ref:`Vector3i<class_Vector3i>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`Vector4<class_Vector4>` | :ref:`operator *<class_int_operator_mul_Vector4>`\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`Vector4i<class_Vector4i>` | :ref:`operator *<class_int_operator_mul_Vector4i>`\ (\ right\: :ref:`Vector4i<class_Vector4i>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`operator *<class_int_operator_mul_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`operator *<class_int_operator_mul_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`operator **<class_int_operator_pow_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`operator **<class_int_operator_pow_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`operator +<class_int_operator_sum_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`operator +<class_int_operator_sum_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`operator -<class_int_operator_dif_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`operator -<class_int_operator_dif_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`operator /<class_int_operator_div_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`operator /<class_int_operator_div_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<<class_int_operator_lt_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<<class_int_operator_lt_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`operator \<\<<class_int_operator_bwsl_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<=<class_int_operator_lte_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<=<class_int_operator_lte_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ==<class_int_operator_eq_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ==<class_int_operator_eq_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ><class_int_operator_gt_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ><class_int_operator_gt_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator >=<class_int_operator_gte_float>`\ (\ right\: :ref:`float<class_float>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator >=<class_int_operator_gte_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`operator >><class_int_operator_bwsr_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`operator ^<class_int_operator_bwxor_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`operator unary+<class_int_operator_unplus>`\ (\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`operator unary-<class_int_operator_unminus>`\ (\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`operator |<class_int_operator_bwor_int>`\ (\ right\: :ref:`int<class_int>`\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`operator ~<class_int_operator_bwnot>`\ (\ ) |
+-------------------------------------+---------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
建構子說明
----------
.. _class_int_constructor_int:
.. rst-class:: classref-constructor
:ref:`int<class_int>` **int**\ (\ ) :ref:`🔗<class_int_constructor_int>`
建構設為 ``0`` 的 **int**\ 。
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`int<class_int>` **int**\ (\ from\: :ref:`int<class_int>`\ )
建構給定 **int** 的副本 **int**\ 。
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`int<class_int>` **int**\ (\ from\: :ref:`String<class_String>`\ )
從 :ref:`String<class_String>` 建構新的 **int**\ ，遵循與 :ref:`String.to_int()<class_String_method_to_int>` 相同的規則。
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`int<class_int>` **int**\ (\ from\: :ref:`bool<class_bool>`\ )
從 :ref:`bool<class_bool>` 建構新的 **int**\ 。\ ``true`` 會轉換為 ``1``\ ，\ ``false`` 會轉換為 ``0``\ 。
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`int<class_int>` **int**\ (\ from\: :ref:`float<class_float>`\ )
從 :ref:`float<class_float>` 建構新的 **int**\ 。這樣會截斷該 :ref:`float<class_float>`\ ，丟棄小數點之後的部分。
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
運算子說明
----------
.. _class_int_operator_neq_float:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_neq_float>`
如果該 **int** 與該 :ref:`float<class_float>` 不等價，則返回 ``true``\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_neq_int:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_neq_int>`
如果 **int** 不相等，則返回 ``true``\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_mod_int:
.. rst-class:: classref-operator
:ref:`int<class_int>` **operator %**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_mod_int>`
返回兩個 **int** 相除後的餘數。該操作使用截斷除法，被除數為負數時會返回負數。如果不希望如此，請考慮使用 :ref:`@GlobalScope.posmod()<class_@GlobalScope_method_posmod>`\ 。
::
print(6 % 2) # 輸出 0
print(11 % 4) # 輸出 3
print(-5 % 3) # 輸出 -2
.. rst-class:: classref-item-separator
----
.. _class_int_operator_bwand_int:
.. rst-class:: classref-operator
:ref:`int<class_int>` **operator &**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_bwand_int>`
執行按位 ``AND`` 運算。
::
print(0b1100 & 0b1010) # 輸出 8（二進位 1000）
可用於從變數中檢索二進位旗標。
::
var flags = 0b101
# 檢查是否啟用了第一或第二個比特位。
if flags & 0b011:
do_stuff() # 會執行這一行。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_mul_Color:
.. rst-class:: classref-operator
:ref:`Color<class_Color>` **operator ***\ (\ right\: :ref:`Color<class_Color>`\ ) :ref:`🔗<class_int_operator_mul_Color>`
將 :ref:`Color<class_Color>` 的每個分量乘以該 **int**\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_mul_Quaternion:
.. rst-class:: classref-operator
:ref:`Quaternion<class_Quaternion>` **operator ***\ (\ right\: :ref:`Quaternion<class_Quaternion>`\ ) :ref:`🔗<class_int_operator_mul_Quaternion>`
將 :ref:`Quaternion<class_Quaternion>` 的每個分量乘以該 **int**\ 。此操作本身沒有意義，但可以用作更大表達式的一部分。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_mul_Vector2:
.. rst-class:: classref-operator
:ref:`Vector2<class_Vector2>` **operator ***\ (\ right\: :ref:`Vector2<class_Vector2>`\ ) :ref:`🔗<class_int_operator_mul_Vector2>`
將 :ref:`Vector2<class_Vector2>` 的每個分量乘以該 :ref:`float<class_float>`\ 。
::
print(2 * Vector2(1, 4)) # 輸出 (2, 8)
.. rst-class:: classref-item-separator
----
.. _class_int_operator_mul_Vector2i:
.. rst-class:: classref-operator
:ref:`Vector2i<class_Vector2i>` **operator ***\ (\ right\: :ref:`Vector2i<class_Vector2i>`\ ) :ref:`🔗<class_int_operator_mul_Vector2i>`
將 :ref:`Vector2i<class_Vector2i>` 的每個分量乘以該 **int**\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_mul_Vector3:
.. rst-class:: classref-operator
:ref:`Vector3<class_Vector3>` **operator ***\ (\ right\: :ref:`Vector3<class_Vector3>`\ ) :ref:`🔗<class_int_operator_mul_Vector3>`
將 :ref:`Vector3<class_Vector3>` 的每個分量乘以該 **int**\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_mul_Vector3i:
.. rst-class:: classref-operator
:ref:`Vector3i<class_Vector3i>` **operator ***\ (\ right\: :ref:`Vector3i<class_Vector3i>`\ ) :ref:`🔗<class_int_operator_mul_Vector3i>`
將 :ref:`Vector3i<class_Vector3i>` 的每個分量乘以該 **int**\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_mul_Vector4:
.. rst-class:: classref-operator
:ref:`Vector4<class_Vector4>` **operator ***\ (\ right\: :ref:`Vector4<class_Vector4>`\ ) :ref:`🔗<class_int_operator_mul_Vector4>`
將 :ref:`Vector4<class_Vector4>` 的每個分量乘以該 **int**\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_mul_Vector4i:
.. rst-class:: classref-operator
:ref:`Vector4i<class_Vector4i>` **operator ***\ (\ right\: :ref:`Vector4i<class_Vector4i>`\ ) :ref:`🔗<class_int_operator_mul_Vector4i>`
將 :ref:`Vector4i<class_Vector4i>` 的每個分量乘以該 **int**\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_mul_float:
.. rst-class:: classref-operator
:ref:`float<class_float>` **operator ***\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_mul_float>`
將 :ref:`float<class_float>` 和該 **int** 相乘。結果為 :ref:`float<class_float>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_mul_int:
.. rst-class:: classref-operator
:ref:`int<class_int>` **operator ***\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_mul_int>`
將兩個 **int** 相乘。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_pow_float:
.. rst-class:: classref-operator
:ref:`float<class_float>` **operator ****\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_pow_float>`
將 **int** 提升到 :ref:`float<class_float>` 次冪。結果為 :ref:`float<class_float>`\ 。
::
print(2 ** 0.5) # 輸出 1.4142135623731
.. rst-class:: classref-item-separator
----
.. _class_int_operator_pow_int:
.. rst-class:: classref-operator
:ref:`int<class_int>` **operator ****\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_pow_int>`
將左側的 **int** 提升到右側的 **int** 次冪。
::
print(3 ** 4) # 輸出 81
.. rst-class:: classref-item-separator
----
.. _class_int_operator_sum_float:
.. rst-class:: classref-operator
:ref:`float<class_float>` **operator +**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_sum_float>`
將該 **int** 加上該 :ref:`float<class_float>`\ 。結果為 :ref:`float<class_float>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_sum_int:
.. rst-class:: classref-operator
:ref:`int<class_int>` **operator +**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_sum_int>`
將兩個 **int** 相加。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_dif_float:
.. rst-class:: classref-operator
:ref:`float<class_float>` **operator -**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_dif_float>`
將該 **int** 減去該 :ref:`float<class_float>`\ 。結果為 :ref:`float<class_float>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_dif_int:
.. rst-class:: classref-operator
:ref:`int<class_int>` **operator -**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_dif_int>`
將兩個 **int** 相減。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_div_float:
.. rst-class:: classref-operator
:ref:`float<class_float>` **operator /**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_div_float>`
將該 **int** 除以該 :ref:`float<class_float>`\ 。結果為 :ref:`float<class_float>`\ 。
::
print(10 / 3.0) # 輸出 3.33333333333333
.. rst-class:: classref-item-separator
----
.. _class_int_operator_div_int:
.. rst-class:: classref-operator
:ref:`int<class_int>` **operator /**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_div_int>`
將兩個 **int** 相除。結果為 **int**\ 。這樣會截斷該 :ref:`float<class_float>`\ ，丟棄小數點後的部分。
::
print(6 / 2) # 輸出 3
print(5 / 3) # 輸出 1
.. rst-class:: classref-item-separator
----
.. _class_int_operator_lt_float:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_lt_float>`
如果該 **int** 小於該 :ref:`float<class_float>`\ ，則返回 ``true``\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_lt_int:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_lt_int>`
如果左側的 **int** 小於右側的 **int**\ ，則返回 ``true``\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_bwsl_int:
.. rst-class:: classref-operator
:ref:`int<class_int>` **operator <<**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_bwsl_int>`
執行按位左移操作。效果上與乘以 2 的冪相同。
::
print(0b1010 << 1) # 輸出 20（二進位 10100）
print(0b1010 << 3) # 輸出 80（二進位 1010000）
.. rst-class:: classref-item-separator
----
.. _class_int_operator_lte_float:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <=**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_lte_float>`
如果該 **int** 小於等於該 :ref:`float<class_float>`\ ，則返回 ``true``\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_lte_int:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <=**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_lte_int>`
如果左側的 **int** 小於等於右側的 **int**\ ，則返回 ``true``\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_eq_float:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_eq_float>`
如果該 **int** 等於該 :ref:`float<class_float>`\ ，則返回 ``true``\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_eq_int:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_eq_int>`
如果兩個 **int** 相等，則返回 ``true``\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_gt_float:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_gt_float>`
如果該 **int** 大於該 :ref:`float<class_float>`\ ，則返回 ``true``\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_gt_int:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_gt_int>`
如果左側的 **int** 大於右側的 **int**\ ，則返回 ``true``\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_gte_float:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >=**\ (\ right\: :ref:`float<class_float>`\ ) :ref:`🔗<class_int_operator_gte_float>`
如果該 **int** 大於等於該 :ref:`float<class_float>`\ ，則返回 ``true``\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_gte_int:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >=**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_gte_int>`
如果左側的 **int** 大於等於右側的 **int**\ ，則返回 ``true``\ 。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_bwsr_int:
.. rst-class:: classref-operator
:ref:`int<class_int>` **operator >>**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_bwsr_int>`
執行按位右移操作。效果上與除以 2 的冪相同。
::
print(0b1010 >> 1) # 輸出 5（二進位 101）
print(0b1010 >> 2) # 輸出 2（二進位 10）
.. rst-class:: classref-item-separator
----
.. _class_int_operator_bwxor_int:
.. rst-class:: classref-operator
:ref:`int<class_int>` **operator ^**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_bwxor_int>`
執行按位 ``XOR``\ （異或）運算。
::
print(0b1100 ^ 0b1010) # 輸出 6（二進位 110）
.. rst-class:: classref-item-separator
----
.. _class_int_operator_unplus:
.. rst-class:: classref-operator
:ref:`int<class_int>` **operator unary+**\ (\ ) :ref:`🔗<class_int_operator_unplus>`
返回與 ``+`` 不存在時相同的值。單目 ``+`` 沒有作用，但有時可以使你的程式碼更具可讀性。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_unminus:
.. rst-class:: classref-operator
:ref:`int<class_int>` **operator unary-**\ (\ ) :ref:`🔗<class_int_operator_unminus>`
返回該 **int** 的相反值。如果為正數，則該將數變為負數。如果為負數，則將該數變為正數。如果為零，則不執行任何操作。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_bwor_int:
.. rst-class:: classref-operator
:ref:`int<class_int>` **operator |**\ (\ right\: :ref:`int<class_int>`\ ) :ref:`🔗<class_int_operator_bwor_int>`
執行按位 ``OR``\ （或）運算。
::
print(0b1100 | 0b1010) # 輸出 14（二進位 1110）
可用於在變數中儲存二進位標記。
::
var flags = 0
flags |= 0b101 # 置第一和第三位。
.. rst-class:: classref-item-separator
----
.. _class_int_operator_bwnot:
.. rst-class:: classref-operator
:ref:`int<class_int>` **operator ~**\ (\ ) :ref:`🔗<class_int_operator_bwnot>`
執行按位 ``NOT``\ （反）運算。由於\ `補數 <https://zh.wikipedia.org/zh-cn/%E4%BA%8C%E8%A3%9C%E6%95%B8>`__\ ，效果上與 ``-(int + 1)`` 相同。
::
print(~4) # 輸出 -5
print(~(-7)) # 輸出 6
.. |virtual| replace:: :abbr:`virtual (本方法通常需要使用者覆寫才能生效。)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (本方法沒有副作用。不會修改該實例的任何成員變數。)`
.. |vararg| replace:: :abbr:`vararg (本方法除了這裡描述的參數外，還可以接受任意數量的參數。)`
.. |constructor| replace:: :abbr:`constructor (本方法用於建構一個型別。)`
.. |static| replace:: :abbr:`static (本方法無需實例即可呼叫，因此可以直接使用類別名稱呼叫。)`
.. |operator| replace:: :abbr:`operator (本方法描述將本型別作為左運算元時可用的有效運算子。)`
.. |bitfield| replace:: :abbr:`BitField (此值是由下列旗標組成的位元遮罩整數。)`
.. |void| replace:: :abbr:`void (無回傳值。)`
Reference in New Issue View Git Blame Copy Permalink