Swift和C#的基本语法对比

Recently, Apple announced and released a beta version of the new Swift programming language for building iOS and OSX applications. Swift is a modern language with the power of Objective-C without the "baggage of C." While we can't argue that Objective-C has it's difficulties being tied closely to C, but the real question is... How does Swift compare to a modern language like C#?

Please, keep in mind that this post is not supposed to be an
Apple vs Microsoft post. There are a lot of developers that use C# every day and
the purpose of this post is to help them understand what Swift offers at a
language level compared to C#. And, before you start the "apples and oranges"
arguments, it's worth pointing out that using Xamarinyou can develop iOS
and OSX apps using C#.

Now let the code mostly speak for
itself...

Code
Comments

Both languages support the same syntax for code comments; the
familiar C-style comments.

1. // code comment
2. /* multi line
3. code comment */

复制代码

Declaring Constants and Variables

Swift, like C#, is a type safe language. It also supports type
inference so you don't have to specify the type when declaring the variables as
the compiler can infer (or detect) the type by evaluating the assignment of the
variable. While C# is slightly more verbose when declaring constants; both
languages are just as elegant at declaring variables using type
inference.

1. // Declare Constant
2. // C#
3. const int legalAge = 18;
4. // Swift
5. let legalAge = 18
6. // Declare Variable
7. // C#
8. var legalAge = 18;
9. // Swift
10. var legalAge = 18

复制代码

While type inference is nice, but when you don't immediately
assign a value to the variable you may need to explicitly specify the type of
the variable.

1. // Type Annotation
2. //C#
3. string firstName;
4. // Swift
5. var firstName: String

复制代码

You may notice the lack of the semi-colon in Swift. Yes, Swift
is a mostly C-style syntax without requiring semi-colons. Swift does support and
require the use of semi-colons if you want to have multiple code statements on
the same line.

Variable Names and
Unicode

Both languages support the use of Unicode characters as variable
names. Basically, you could use Emoticons or other non-ASCII characters as
variable names if you want, but who does that
anyway?

Integer Bounds

Both languages have static constants for accessing the minimum
and maximum bounds for the different Integer types.

1. // Integer Bounds
2. // C#
3. var a = Int32.MinValue;
4. var b = Int32.MaxValue;
5. // Swift
6. var a = Int32.min
7. var b = Int32.max

复制代码

Type Inference

Both languages, as mentioned above, support type inference where
the compiler is able to detect what type the declared variable is from it's
immediate assignment.

1. // Type Inference
2. // C#
3. var a = 3; // integer
4. var b = 0.14 // double
5. var c = a + b; // double
6. // Swift
7. var a = 3 // integer
8. var b = 0.14 // double
9. var c = a + b // double

复制代码

Also in the above type inference example you'll notice that when
you declare a variable and immediately assign a value that is the result of 2
other variables it will still infer the type.

String Comparison

Both have similar methods of comparing strings.

1. // String Comparison
2. // C#
3. var a = "One";
4. var b = "One";
5. if (a == b) {
6. // both variables are considered equal
7. }
8. // Swift
9. var a = "One"
10. var b = "One"
11. if a == b {
12. // both variables are considered equal
13. }

复制代码

The both also have similar methods of detecting if the beginning
or ending of the string match's a specified string.

1. // C#
2. var s = "Some Value";
3. if (s.StartsWith("Some")) {
4. // the string starts with the value
5. }
6. if (s.EndsWith("Value")) {
7. // the string ends with the value
8. }
9. // Swift
10. var s = "Some Value"
11. if s.hasPrefix("Some") {
12. // the string starts with the value
13. }
14. if s.hasSuffix("Value") {
15. // the string ends with the value
16. }

复制代码

You may notice from the above example that parenthesis are not
required with IF statements in Swift.

String Upper or Lower Case

Both languages support similar methods of converting strings to
Upper or Lower Case.

1. // String Upper and Lower Case
2. // C#
3. var s = "some Value";
4. var upperS = s.ToUpper();
5. var lowerS = s.ToLower();
6. // Swift
7. var s = "some Value"
8. var upperS = s.uppercaseString
9. var lowerS = s.lowercaseString

复制代码

Declaring Arrays

Both languages support declaring and assigning Arrays using a
single line of code.

1. // Declare Arrays on single line
2. // String Array
3. // C#
4. var arr = new string[] { "One", "Two" };
5. // Swift
6. var arr = ["One", "Two"]
7. // Integer Array
8. // C#
9. var arr = new int[] { 1, 2 };
10. // Swift
11. var arr = [1, 2];

复制代码

Working with Arrays

Working with Arrays have slight differences between the
languages.

1. // Iterating Over Array
2. // C#
3. foreach (var item in arr) {
4. // do something
5. }
6. // Swift
7. for item in arr {
8. // do something
9. }
10. // Get Item at Index
11. // C#
12. var item = arr[0];
13. // Swift
14. var item = arr[0]
15. // Set Item at Index
16. // C#
17. arr[0] = "Value";
18. // Swift
19. arr[0] = "Value"
20. // Is Array Empty?
21. // C#
22. if (arr.Length == 0) {
23. // array is empty
24. }
25. // Swift
26. if arr.isEmpty {
27. // array is empty
28. }
29. // Add Item to Array
30. // C#
31. Array.Resize(ref arr, arr.Length + 1);
32. arr[arr.Length - 1] = "Three";
33. // Swift
34. arr.append("Three")
35. // or
36. arr += "Three"
37. // Remove Item at Index
38. // C#
39. var list = arr.ToList();
40. list.RemoveAt(0);
41. var newArr = list.ToArray();
42. // Swift
43. var newArr = arr.removeAtIndex(0)

复制代码

Declaring Dictionaries

Both languages support similar methods of declaring
dictionaries.

1. // Declaring Dictionaries
2. // C#
3. var dict = new Dictionary<string, string>();
4. var dict2 = new Dictionary<string, string>
5. {
6. { "TYO", "Tokyo" },
7. { "DUB", "Dublin" }
8. };
9. // Swift
10. var dict = Dictionary<String, String>()
11. var dict2 = ["TYO": "Tokyo", "DUB": "Dublin"]

复制代码

Working with Dictionaries

Working with Dictionaries have slight differences between the
languages.

1. // Iterate over Dictionary
2. // C#
3. foreach(var item in dict) {
4. var key = item.Key;
5. var value = item.Value;
6. }
7. // Swift
8. for (key, value) in dict {
9. // key variable contains key of item
10. // value variable contains value of item
11. }
12. // Get Item in Dictionary by Key
13. // C#
14. var item = dict["TYO"];
15. // Swift
16. var item = dict["TYO"]
17. // Set Item in Dictionary by key
18. // or add if key doesn't exist
19. // C#
20. dict["LHR"] = "London";
21. // Swift
22. dict["LHR"] = "London"
23. // Remove Item in Dictionary by key
24. // C#
25. dict.Remove("LHR");
26. // Swift
27. dict.removeValueForKey("DUB")

复制代码

For Loops

The above examples for Arrays and Dictionaries already showed
examples of using a For-In loop to iterate through the items in those
collections. Here are some additional methods of iterating using a For
Loop.

1. // Iterate from 1 through 5
2. // C#
3. // using increment
4. for(var i = 1; i <= 5; i++) {
5. // do something with i
6. }
7. // Swift
8. // using range
9. for i in 1...5 {
10. // do something with i
11. }
12. // using increment
13. for var i = 0; i <= 5; ++i {
14. // do something with i
15. }

复制代码

The range example of Swift is rather interesting in the method
of shorthand it uses for it's definition.

Conditional Statements

Both languages support If...Then conditional statements. Swift
is a little different that it doesn't require parenthesis around the match
conditions.

1. // If Then Else Conditional Statement
2. // C#
3. if (i > 6) {
4. // do something
5. } else if (i > 3 && i <= 6) {
6. // do something
7. } else {
8. // do something
9. }
10. // Swift
11. if i > 6 {
12. // do something
13. } else if i > 3 && i <= 6 {
14. // do something
15. } else {
16. // do something
17. }

复制代码

Switch Statement

Both languages support Switch statements.

1. // Switch statement
2. // C#
3. var word = "A";
4. switch(word) {
5. case "A":
6. // do something
7. break;
8. case "B":
9. // do something
10. break;
11. default:
12. // do something
13. break;
14. }
15. // Swift
16. var word = "A"
17. switch word {
18. case "A":
19. // do something
20. case "B":
21. // do something
22. default:
23. // do something
24. }

复制代码

Switch statements are rather similar in both languages except
that in Swift case statements don't automatically pass on to the next like in
C#. As a result C# requires the use of the break keywords to exit the Switch
statement, unless you want to fall through to the next case. While in Swift you
must use the "fallthrough" keyword to tell it to pass on through to the next
case statement. More information on this can be found in the Swift
documentation.

An additional feature that Swift supports with Switch statements
is ranges within the Case statements. This is something that C# does not
support.

1. // Switch Case Ranges
2. // C#
3. switch (i) {
4. case 1:
5. case 2:
6. case 3:
7. // do something
8. break;
9. case 4:
10. // do something
11. break;
12. default:
13. // do something
14. break;
15. }
16. // Swift
17. switch i {
18. case 1...3:
19. // do something
20. case 4:
21. // do something
22. default:
23. // do something
24. }

复制代码

Functions

While Functions are a much bigger comparison to be made,
here's a basic example:

1. // Function with Parameter and Return Value
2. // C#
3. string sayHello(string name) {
4. // do something
5. }
6. // Swift
7. func sayHello(name: String) -> String {
8. // do something
9. }

复制代码

The post Basic Comparison of Functions in C# and Swift goes into
much more depth on Functions; as that is a much bigger comparison that could fit
into this post.

Conclusion

This concludes my basic comparison of C# and Apple Swift
programming languages. The two languages are rather similar in many respects; at
least in what I've compared thus far. More language feature comparisons will
have to wait for future posts.

One of the bigger differences that's worth pointing out
explicitly is the difference in how each language handles Array's. Arrays in
Swift are extremely similar to the List<> class in C#; which is what most
developers use today in C# instead of arrays anyway (unless performance requires
it.)

You can find more information about the Swift programming
language on Apple's site at the following links:

https://developer.apple.com/swift/

https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/