斯威夫特——字面量

字面量量是整数、十进制数、字符串等的实际值。或者我们可以说字面量是变量或常量的值。我们可以直接在程序中使用字面量而无需任何计算。默认情况下，在 Swift 中，字面量本身没有任何类型。原始类型变量可以用字面量赋值。例如，12 是整数字面量，3.123 是浮点字面量，“GeeksforGeeks”是字符串字面量，true 是布尔字面量。当我们为字面量量指定类型注解时，类型注解必须是可以从字面量量值推断出的类型。注解类型必须遵循 Swift 标准库协议：

• ExpressibleByIntegerLiteral：这用于整数字面量。
• ExpressibleByFloatLiteral：这用于浮点字面量。
• ExpressibleByStringLiteral：这用于字符串字面量。
• ExpressibleByBooleanLiteral：这用于布尔字面量。

例如，Int32 遵循“ExpressibleByIntegerLiteral 协议”，因此我们将其用作字面量值 25 的类型注释，如：

let x: Int32 = 25.

Swift 主要支持四种类型的字面量，如下所述。

整数字面量

整数字面量用于表示整数值。如果未指定整数的备用基数，则分配默认类型，即以 10 为基数的十进制。我们也可以使用减号（-）运算符来指定负整数字面量。例如：

-25 // literal

这些字面量还可以在其数字之间包含下划线 (_) 以更好地表示数字，但这些下划线被忽略并且对字面量的整体值没有影响。

例如：

// Both integer literals are the same

025 // literal 1
25  // literal 2

甚至，我们可以在整数字面量中使用前导零，但它们对字面量的整体值没有影响。例如，

// Both integer literals are the same

025 // literal 1
25  // literal 2

整数字面量是数值，可以是其中之一

• 二进制常量：一个二进制常量只能包含两个值，0 或 1。
• 十进制常量：十进制常量可以包含 0 到 9 范围内的值。
• 八进制常数：八进制常数可以包含 0 到 7 范围内的值。
• 十六进制常量：十六进制常量可以包含 0 到 9 或 A 到 F 或 a 到 f 范围内的值。

默认情况下，整数字面量本身没有类型。例如，

let myVariable: Int32 = 10

Swift 使用其显式类型表示法来推断字面量量 20 是 Int32 类型。当不使用显式类型表示法时，swift 编译器会推断出文字的类型是 Swift 标准库中预定义的默认字面量类型之一。所以整数字面量的默认类型是 Int。除了十进制字面量，所有字面量常量都以如下指定的前缀开头，

• 二进制：0b
• 十进制：无前缀
• 八进制：0o
• 十六进制：0x

这些与字面量一起使用的前缀对于编译器来说是唯一的并且具有特殊含义。下面是 Swift 中使用这些字面量的实现。

例子：

在下面的程序中，我们将数字 10 表示为十进制的 10，二进制的 0b1010，八进制的 0o12，十六进制的 0xA。

Swift

// Swift program to demonstrate the working of literals
  
// Initializing variables
// 10 in decimal notation
let decimalNumber = 10    
  
// 10 in binary notation
let binaryNumber = 0b1010   
  
// 10 in octal notation
let octalNumber = 0o12 
  
// 10 in hexadecimal notation
let hexadecimalNumber = 0xA   
  
// Print these numbers
print("Decimal Number:", decimalNumber)
print("Binary Number:", binaryNumber)
print("Octal Number:", octalNumber)
print("Hexadecimal Number:", hexadecimalNumber)

输出：

Decimal Number: 10
Binary Number: 10
Octal Number: 10
Hexadecimal Number: 10

浮点字面量

浮点字面量在其表示中具有小数点。在这里，十进制浮点字面量表示一个十进制数字序列，后跟一个小数部分，或一个十进制指数，或两者兼而有之。浮点字面量不拥有自己的任何类型。如果未指定浮点字面量的备用基数，则分配默认类型，即以 10 为基数，即十进制。我们也可以使用减号（-）运算符来指定负浮点字面量。例如，

-1.123 // literal

与整数字面量一样，我们可以在浮点字面量的数字之间使用下划线。这些下划线被忽略，对浮点字面量的整体值没有影响。例如，

// Both floating-point literals are the same

0.2_5 // literal 1
0.25  // literal 2

我们可以提供显式类型表示法来推断浮点字面量量是 Float 类型。例如，

let myVariable: Float = 10.123 // Explicitly specifying that myVariable is of type Float

当我们不使用显式类型表示法时，Swift 编译器会推断字面量字面量类型之一。例如，

let myVariable = 10.123 // Swift compiler internally infers that myVariable is of type Double

所以浮点字面量的默认类型是 Double。有两种方法可以对浮点字面量进行分类：

1. 十进制浮点字面量：它表示一个十进制数字序列，后跟一个小数部分，或一个十进制指数，或两者兼而有之。它由一个可选的指数组成，用大写字母 (E) 或小写字母 (e) 表示。如果十进制浮点数以 x 作为指数，则底数乘以 10 ^x 。例如，

// Both are the same value
0.25e1 
2.5 

示例：在下面的程序中，我们表示 decimalFloatingNumber2 等于 = 0.123e2 = 0.123 * 10 ² = 12.3。

迅速

// Swift program to demonstrate the working of
// decimal floating-point literal
  
// Initializing variables
let decimalFloatingNumber1 = 0.12  
let decimalFloatingNumber2 = 0.123e2  
  
// Display the result
print("decimalFloatingNumber1: \(decimalFloatingNumber1)")  
print("decimalFloatingNumber2: \(decimalFloatingNumber2)")

输出：

decimalFloatingNumber1: 0.12
decimalFloatingNumber2: 12.3

2. 十六进制浮点字面量：十六进制浮点字面量由一个指数组成，由大写 (P) 或小写 (p) 表示。如果在此字面量中 x 是指数，则底数乘以 2 ^x 。例如，

// Both are the same value
0.25p1 
0.5

示例：在下面的程序中，我们表示 hexadecimalFloatingNumber1 等于 = 0xFp1 = 15 * 2 ¹ = 30，因为十六进制中的 F 等于 15，而 hexadecimalFloatingNumber2 等于 = 0xFp-1 = 15 * 2 ^-1 = 7.5 因为 F 在十六进制等于 15。

迅速

// Swift program to demonstrate the working of 
// Hexadecimal floating-point literal
  
// Initializing variables
let hexadecimalFloatingNumber1 = 0xFp1 
let hexadecimalFloatingNumber2 = 0xFp-1  
    
// Print variables
print("hexadecimalFloatingNumber1: \(hexadecimalFloatingNumber1)")  
print("hexadecimalFloatingNumber2: \(hexadecimalFloatingNumber2)")

输出：

hexadecimalFloatingNumber1: 30.0
hexadecimalFloatingNumber2: 7.5

字符串字面量

单行字符串字面量是由两个双引号括起来的字母或字符的集合。例如，

"GeeksforGeeks" // A string literal

例子：

迅速

// Swift program to demonstrate the 
// working of string literals
  
// Initializing strings
let myString1 = "GeeksforGeeks"
let myString2 = "Geeks" 
  
// Print strings
print(myString1)
print(myString2)

输出：

GeeksforGeeks
Geeks

字符串字面量本身不具有任何类型，但如果未指定类型，则内部分配的默认类型为字符串。 Swift 使用其显式类型表示法来推断字面量量“GeeksforGeeks”是 String 类型。当不使用显式类型表示法时，Swift 编译器会推断文字的类型是 Swift 标准库中预定义的默认字面量类型之一。例如，

let myVariable = "GeeksforGeeks"           // Default type is String
let myVariable: String = "GeeksforGeeks"   // Explicitly specifying that the 
                                           // "GeeksforGeeks" is of type String

转义序列是特殊的字符序列。当它们在字符串中使用时，它们不是代表自己，而是被翻译成另一个难以直接表示的字符或字符序列。字符串字面量不能有未转义的双引号 (")、回车、未转义的反斜杠 (\) 或换行符。

在 Swift 中，我们也可以使用多行字面量。多行字符串字面量由三个双引号括起来。或者我们可以说在开始和结束三个双引号之间存在多个字符串。您还可以使用反斜杠 (\) 来分隔多行字符串字面量内的行。例如，

let myVariable: String = """
                            GeeksforGeeks \
                            GFG
                            
                         """

我们可以使用以下转义序列在字符串字面量中包含特殊字符。

Escape sequences	Significance
\b	Backspace
\0	Null Character
\\	Backslash
\f	Form feed
\n	Newline
\r	Carriage return
\t	Horizontal tab
\v	Vertical tab
\’	Single Quotation mark
\”	Double Quotation mark
Unicode scalar (\u{n})	Here, n is a hexadecimal number that contains one to eight digits

我们可以通过在表达式之前使用反斜杠字符来使用表达式的实际值。表达式必须用括号括起来。请注意，表达式只能包含字符串字面量。换句话说，我们不能在表达式中使用未转义的反斜杠、回车或换行。

例如：

// All the following string literals are the same

"5 6 7"
"5 6 \("7")"
"5 6 \(7)"
"5 6 \(3 + 4)"

let x = 7; 
"5 6 \(x)"

由双引号和一组平衡的数字符号 (#) 包围的字符串称为“由扩展分隔符分隔的字符串”。这些字符串具有以下形式，

// Delimited string 1
#"GeeksforGeeks"#

// Delimited string 2
#"""
GeeksforGeeks
"""#

我们可以通过将特殊字符转换为分隔字符串来使特殊字符在最终输出中显示为普通字符。

例子：

迅速

// Swift program to illustrate the working of delimited strings
  
// Initializing a constant variable
let x = 10
  
// Initializing another variable using a delimited string
let delimitedString = #"\(x)"#
  
// Initializing another variable using a 
// non-delimited string literal
let normalString = "\\(x)"
  
print("delimitedString:", delimitedString)
print("normalString:", normalString)
  
print("Are delimitedString and normalString equal?",
      delimitedString == normalString)
// Prints "true"

输出：

delimitedString: \(x)
normalString: \(x)
Are delimitedString and normalString equal? true

当使用一组以上的扩展定界符时，定界符之间不得有空格。那是，

let delimitedString = ##"\(x)"# #   //  Wrong
let delimitedString = ##"\(x)"##    //  Right

在 Swift 中，我们可以连接两个字符串字面量，并且连接发生在编译时。

句法：

string1 = "Bhuwanesh"  // String 1
string2 = "Nainwal"    // String 2

string1 + string2   // "Bhuwanesh Nainwal"

请注意，连接期间字符串的顺序很重要。

例子：

迅速

// Swift program to concatenate two strings
  
// Initializing a string
let string1 = "GeekforGeeks is one of the "
  
// Initializing another string
// by directly concatenating two strings
let string2 = "best learning " + "platforms."
  
// Concatenate strings
let result = string1 + string2
  
// Print the resulting string
// after concatenation
print("result:", result)

输出：

result: GeekforGeeks is one of the best learning platforms.

布尔字面量

布尔字面量可以表示以下类型的值之一，

• 真的
• 错误的

布尔字面量不包含它自己的任何类型。例如，

let myVariable: Bool = true

我们可以使用显式类型表示法来推断字面量true具有 Bool 类型。当不使用显式类型表示法时，swift 编译器会推断出文字的类型是 Swift 标准库中预定义的默认字面量类型之一。所以布尔字面量的默认类型是布尔值。

例子：

迅速

// Swift program to demonstrate the
// working of boolean literals
  
// Initializing strings
let booleanNumber1 = true 
let booleanNumber2 = false  
  
// Print the value represented by variables
print("booleanNumber1: \(booleanNumber1)")  
print("booleanNumber2: \(booleanNumber2)")

输出：

booleanNumber1: true
booleanNumber2: false