Swift - ฟังก์ชั่น

ฟังก์ชันคือชุดของคำสั่งที่จัดระเบียบร่วมกันเพื่อทำงานเฉพาะ ฟังก์ชัน Swift 4 สามารถทำได้ง่ายเหมือนกับฟังก์ชัน C ธรรมดาไปจนถึงซับซ้อนเท่ากับฟังก์ชันภาษา Objective C ช่วยให้เราสามารถส่งผ่านค่าพารามิเตอร์ภายในและส่วนกลางภายในการเรียกใช้ฟังก์ชัน

• Function Declaration - บอกคอมไพเลอร์เกี่ยวกับชื่อของฟังก์ชันประเภทการส่งคืนและพารามิเตอร์

• Function Definition - ให้ตัวจริงของฟังก์ชั่น

ฟังก์ชัน Swift 4 ประกอบด้วยประเภทพารามิเตอร์และประเภทการส่งคืน

นิยามฟังก์ชัน

ใน Swift 4 ฟังก์ชันถูกกำหนดโดยคีย์เวิร์ด "func" เมื่อฟังก์ชันถูกกำหนดขึ้นใหม่อาจใช้ค่าหนึ่งหรือหลายค่าเป็น 'พารามิเตอร์' อินพุตให้กับฟังก์ชันและจะประมวลผลฟังก์ชันในเนื้อหาหลักและส่งกลับค่าไปยังฟังก์ชันเป็น 'ชนิดส่งคืน' ของเอาต์พุต

ทุกฟังก์ชันมีชื่อฟังก์ชันซึ่งอธิบายถึงงานที่ฟังก์ชันดำเนินการ ในการใช้ฟังก์ชันคุณ "เรียกใช้" ฟังก์ชันนั้นด้วยชื่อและส่งค่าอินพุต (เรียกว่าอาร์กิวเมนต์) ที่ตรงกับประเภทของพารามิเตอร์ของฟังก์ชัน พารามิเตอร์ฟังก์ชันเรียกอีกอย่างว่า 'tuples'

อาร์กิวเมนต์ของฟังก์ชันจะต้องถูกจัดเตรียมไว้ในลำดับเดียวกันกับรายการพารามิเตอร์ของฟังก์ชันเสมอและค่าที่ส่งคืนจะตามด้วย→

ไวยากรณ์

func funcname(Parameters) -> returntype {
   Statement1
   Statement2
   ---
   Statement N
   return parameters
}

ดูรหัสต่อไปนี้ ชื่อของนักเรียนจะถูกประกาศเป็นประเภทข้อมูลสตริงที่ประกาศอยู่ในฟังก์ชัน 'นักเรียน' และเมื่อเรียกใช้ฟังก์ชันนั้นจะส่งคืนชื่อนักเรียน

func student(name: String) -> String {
   return name
}

print(student(name: "First Program"))
print(student(name: "About Functions"))

เมื่อเรารันโปรแกรมข้างต้นโดยใช้สนามเด็กเล่นเราจะได้ผลลัพธ์ดังนี้ -

First Program
About Functions

เรียกใช้ฟังก์ชัน

สมมติว่าเรากำหนดฟังก์ชันที่เรียกว่า 'display' เพื่อพิจารณาตัวอย่างเช่นการแสดงตัวเลขฟังก์ชันที่มีชื่อฟังก์ชัน 'display' จะเริ่มต้นก่อนด้วยอาร์กิวเมนต์ 'no1' ซึ่งมีประเภทข้อมูลจำนวนเต็ม จากนั้นอาร์กิวเมนต์ 'no1' จะถูกกำหนดให้กับอาร์กิวเมนต์ 'a' ซึ่งต่อจากนี้จะชี้ไปที่จำนวนเต็มชนิดข้อมูลเดียวกัน ตอนนี้อาร์กิวเมนต์ 'a' จะถูกส่งกลับไปที่ฟังก์ชัน ฟังก์ชัน display () ที่นี่จะเก็บค่าจำนวนเต็มและส่งกลับค่าจำนวนเต็มเมื่อแต่ละครั้งและทุกครั้งที่เรียกใช้ฟังก์ชัน

func display(no1: Int) -> Int {
   let a = no1
   return a
}

print(display(no1: 100))
print(display(no1: 200))

เมื่อเรารันโปรแกรมด้านบนโดยใช้สนามเด็กเล่นเราจะได้ผลลัพธ์ดังต่อไปนี้ -

100
200

พารามิเตอร์และค่าส่งกลับ

Swift 4 มีพารามิเตอร์ฟังก์ชันที่ยืดหยุ่นและค่าที่ส่งกลับจากค่าง่ายไปจนถึงค่าที่ซับซ้อน เช่นเดียวกับ C และ Objective C ฟังก์ชันใน Swift 4 อาจมีหลายรูปแบบ

ฟังก์ชันที่มีพารามิเตอร์

มีการเข้าถึงฟังก์ชันโดยการส่งผ่านค่าพารามิเตอร์ไปยังเนื้อหาของฟังก์ชัน เราสามารถส่งผ่านค่าพารามิเตอร์เดียวไปยังหลายค่าเป็นสิ่งที่อยู่ภายในฟังก์ชัน

func mult(no1: Int, no2: Int) -> Int {
   return no1*no2
}

print(mult(no1: 2, no2: 20))
print(mult(no1: 3, no2: 15))
print(mult(no1: 4, no2: 30))

เมื่อเรารันโปรแกรมด้านบนโดยใช้สนามเด็กเล่นเราจะได้ผลลัพธ์ดังต่อไปนี้ -

40
45
120

ฟังก์ชันที่ไม่มีพารามิเตอร์

นอกจากนี้เรายังอาจมีฟังก์ชันที่ไม่มีพารามิเตอร์ใด ๆ

ไวยากรณ์

func funcname() -> datatype {
   return datatype
}

ต่อไปนี้เป็นตัวอย่างที่มีฟังก์ชันที่ไม่มีพารามิเตอร์ -

func votersname() -> String {
   return "Alice"
}
print(votersname())

เมื่อเรารันโปรแกรมข้างต้นโดยใช้สนามเด็กเล่นเราจะได้ผลลัพธ์ดังนี้ -

Alice

ฟังก์ชันที่มีค่าส่งคืน

ฟังก์ชั่นยังใช้เพื่อส่งคืนค่าประเภทข้อมูลสตริงจำนวนเต็มและลอยเป็นชนิดส่งคืน หากต้องการค้นหาจำนวนที่มากที่สุดและน้อยที่สุดในฟังก์ชันอาร์เรย์ที่กำหนด 'ls' จะถูกประกาศด้วยประเภทข้อมูลจำนวนเต็มขนาดใหญ่และขนาดเล็ก

อาร์เรย์เริ่มต้นเพื่อเก็บค่าจำนวนเต็ม จากนั้นอาร์เรย์จะถูกประมวลผลและแต่ละค่าในอาร์เรย์จะถูกอ่านและเปรียบเทียบกับค่าก่อนหน้า เมื่อค่าน้อยกว่าค่าก่อนหน้านี้จะถูกเก็บไว้ในอาร์กิวเมนต์ 'เล็ก' มิฉะนั้นจะถูกเก็บไว้ในอาร์กิวเมนต์ 'ใหญ่' และค่าจะถูกส่งกลับโดยการเรียกใช้ฟังก์ชัน

func ls(array: [Int]) -> (large: Int, small: Int) {
   var lar = array[0]
   var sma = array[0]

   for i in array[1..<array.count] {
      if i < sma {
         sma = i
      } else if i > lar {
         lar = i
      }
   }
   return (lar, sma)
}

let num = ls(array: [40,12,-5,78,98])
print("Largest number is: \(num.large) and smallest number is: \(num.small)")

เมื่อเรารันโปรแกรมข้างต้นโดยใช้สนามเด็กเล่นเราจะได้ผลลัพธ์ดังนี้ -

Largest number is: 98 and smallest number is: -5

ฟังก์ชันที่ไม่มีค่าส่งคืน

บางฟังก์ชันอาจมีการประกาศอาร์กิวเมนต์ภายในฟังก์ชันโดยไม่มีค่าส่งกลับ โปรแกรมต่อไปนี้ประกาศa และ bเป็นอาร์กิวเมนต์ของฟังก์ชัน sum () ภายในฟังก์ชันนั้นมีค่าสำหรับอาร์กิวเมนต์a และ b จะถูกส่งผ่านโดยการเรียกใช้ฟังก์ชันการเรียก sum () และค่าของมันจะถูกพิมพ์ออกมาดังนั้นจึงกำจัดค่าที่ส่งคืน

func sum(a: Int, b: Int) {
   let a = a + b
   let b = a - b
   print(a, b)
}

sum(a: 20, b: 10)
sum(a: 40, b: 10)
sum(a: 24, b: 6)

เมื่อเรารันโปรแกรมข้างต้นโดยใช้สนามเด็กเล่นเราจะได้ผลลัพธ์ดังนี้ -

30 20
50 40
30 24

ฟังก์ชั่นที่มีประเภทผลตอบแทนเสริม

Swift 4 แนะนำคุณสมบัติ 'ทางเลือก' เพื่อกำจัดปัญหาโดยการแนะนำมาตรการด้านความปลอดภัย ลองพิจารณาตัวอย่างเช่นเรากำลังประกาศค่าฟังก์ชันที่ส่งกลับประเภทเป็นจำนวนเต็ม แต่จะเกิดอะไรขึ้นเมื่อฟังก์ชันส่งคืนค่าสตริงหรือค่าศูนย์ ในกรณีนั้นคอมไพเลอร์จะส่งคืนค่าความผิดพลาด "ทางเลือก" ได้รับการแนะนำเพื่อกำจัดปัญหาเหล่านี้

ฟังก์ชันเสริมจะใช้สองรูปแบบ 'value' และ 'nil' เราจะพูดถึง 'ตัวเลือก' ด้วยอักขระสงวนคีย์ '?' เพื่อตรวจสอบว่าทูเปิลส่งคืนค่าหรือค่าศูนย์

func minMax(array: [Int]) -> (min: Int, max: Int)? {
   if array.isEmpty { return nil }
   var currentMin = array[0]
   var currentMax = array[0]
   
   for value in array[1..<array.count] {
      if value < currentMin {
         currentMin = value
      } else if value > currentMax {
         currentMax = value
      }
   }
   return (currentMin, currentMax)
}

if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
   print("min is \(bounds.min) and max is \(bounds.max)")
}

เมื่อเราเรียกใช้โปรแกรมด้านบนโดยใช้สนามเด็กเล่นเราจะได้รับผลลัพธ์ดังต่อไปนี้ -

min is -6 and max is 109

'' ตัวเลือก 'ใช้เพื่อตรวจสอบค่า' ศูนย์ 'หรือขยะจึงใช้เวลามากในการดีบักและทำให้รหัสมีประสิทธิภาพและสามารถอ่านได้สำหรับผู้ใช้

ฟังก์ชัน Local Vs ชื่อพารามิเตอร์ภายนอก

ชื่อพารามิเตอร์ท้องถิ่น

ชื่อพารามิเตอร์โลคัลถูกเข้าถึงภายในฟังก์ชันเพียงอย่างเดียว

func sample(number: Int) {
   print(number)
}

ที่นี่ funcหมายเลขอาร์กิวเมนต์ตัวอย่างถูกประกาศเป็นตัวแปรภายในเนื่องจากมีการเข้าถึงภายในโดยฟังก์ชันตัวอย่าง () ที่นี่ 'number' ถูกประกาศให้เป็นตัวแปรภายใน แต่การอ้างอิงถึงตัวแปรนั้นทำนอกฟังก์ชันด้วยคำสั่งต่อไปนี้ -

func sample(number: Int) {
   print(number)
}

sample(number: 1)
sample(number: 2)
sample(number: 3)

เมื่อเรารันโปรแกรมข้างต้นโดยใช้สนามเด็กเล่นเราจะได้ผลลัพธ์ดังนี้ -

1
2
3

ชื่อพารามิเตอร์ภายนอก

ชื่อพารามิเตอร์ภายนอกช่วยให้เราสามารถตั้งชื่อพารามิเตอร์ของฟังก์ชันเพื่อให้วัตถุประสงค์ของมันชัดเจนยิ่งขึ้น ตัวอย่างด้านล่างคุณสามารถตั้งชื่อพารามิเตอร์ฟังก์ชันสองตัวจากนั้นเรียกใช้ฟังก์ชันนั้นดังนี้ -

func pow(firstArg a: Int, secondArg b: Int) -> Int {
   var res = a
   for _ in 1..<b {
      res = res * a
   }
   print(res)
   return res
}

pow(firstArg:5, secondArg:3)

เมื่อเรารันโปรแกรมข้างต้นโดยใช้สนามเด็กเล่นเราจะได้ผลลัพธ์ดังนี้ -

125

พารามิเตอร์ตัวแปร

เมื่อเราต้องการกำหนดฟังก์ชันที่มีอาร์กิวเมนต์จำนวนมากเราสามารถประกาศสมาชิกเป็นพารามิเตอร์ 'ตัวแปร' ได้ พารามิเตอร์สามารถระบุเป็นตัวแปรได้โดย (···) หลังชื่อพารามิเตอร์

func vari<N>(members: N...){
   for i in members {
      print(i)
   }
}

vari(members: 4,3,5)
vari(members: 4.5, 3.1, 5.6)
vari(members: "Swift 4", "Enumerations", "Closures")

เมื่อเรารันโปรแกรมข้างต้นโดยใช้สนามเด็กเล่นเราจะได้ผลลัพธ์ดังนี้ -

4
3
5
4.5
3.1
5.6
Swift 4
Enumerations
Closures

พารามิเตอร์คงที่ตัวแปรและ I / O

ฟังก์ชันโดยค่าเริ่มต้นถือว่าพารามิเตอร์เป็น 'ค่าคงที่' ในขณะที่ผู้ใช้สามารถประกาศอาร์กิวเมนต์ให้ฟังก์ชันเป็นตัวแปรได้เช่นกัน เราได้พูดคุยกันแล้วว่าคำหลัก 'let' ใช้เพื่อประกาศพารามิเตอร์คงที่และพารามิเตอร์ตัวแปรถูกกำหนดด้วยคำหลัก 'var'

พารามิเตอร์ I / O ใน Swift 4 มีฟังก์ชันในการรักษาค่าพารามิเตอร์แม้ว่าค่าจะถูกแก้ไขหลังจากการเรียกใช้ฟังก์ชัน ที่จุดเริ่มต้นของนิยามพารามิเตอร์ฟังก์ชันคำหลัก 'inout' จะถูกประกาศเพื่อคงค่าสมาชิกไว้

มันได้มาจากคำหลัก 'inout' เนื่องจากค่าของมันถูกส่งผ่าน 'in' ไปยังฟังก์ชันและค่าของมันจะถูกเข้าถึงและแก้ไขโดยเนื้อหาของฟังก์ชันและจะถูกส่งกลับกลับ 'out' ของฟังก์ชันเพื่อแก้ไขอาร์กิวเมนต์ดั้งเดิม

ตัวแปรจะถูกส่งผ่านเป็นอาร์กิวเมนต์สำหรับพารามิเตอร์เข้า - ออกเท่านั้นเนื่องจากค่าของตัวแปรเพียงอย่างเดียวจะถูกแก้ไขภายในและภายนอกฟังก์ชัน จึงไม่จำเป็นต้องประกาศสตริงและตัวอักษรเป็นพารามิเตอร์เข้า - ออก '&' ก่อนชื่อตัวแปรหมายถึงเรากำลังส่งอาร์กิวเมนต์ไปยังพารามิเตอร์ in-out

func temp(a1: inout Int, b1: inout Int) {
   let t = a1
   a1 = b1
   b1 = t
}

var no = 2
var co = 10
temp(a1: &no, b1: &co)
print("Swapped values are \(no), \(co)")

เมื่อเรารันโปรแกรมข้างต้นโดยใช้สนามเด็กเล่นเราจะได้ผลลัพธ์ดังนี้ -

Swapped values are 10, 2

ประเภทฟังก์ชันและการใช้งาน

แต่ละฟังก์ชันจะทำตามฟังก์ชันเฉพาะโดยพิจารณาจากพารามิเตอร์อินพุตและผลลัพธ์ที่ต้องการ

func inputs(no1: Int, no2: Int) -> Int {
   return no1/no2
}

ต่อไปนี้เป็นตัวอย่าง -

func inputs(no1: Int, no2: Int) -> Int {
   return no1/no2
}

print(inputs(no1: 20, no2: 10))
print(inputs(no1: 36, no2: 6))

เมื่อเรารันโปรแกรมข้างต้นโดยใช้สนามเด็กเล่นเราจะได้ผลลัพธ์ดังนี้ -

2
6

ที่นี่ฟังก์ชันเริ่มต้นด้วยสองอาร์กิวเมนต์ no1 และ no2 เป็นชนิดข้อมูลจำนวนเต็มและประเภทการส่งคืนยังประกาศเป็น 'int'

Func inputstr(name: String) -> String {
   return name
}

ที่นี่ฟังก์ชั่นถูกประกาศเป็น string ประเภทข้อมูล.

ฟังก์ชั่นอาจมี void ชนิดข้อมูลและฟังก์ชันดังกล่าวจะไม่ส่งคืนอะไรเลย

func inputstr() {
   print("Swift 4 Functions")
   print("Types and its Usage")
}
inputstr()

เมื่อเรารันโปรแกรมข้างต้นโดยใช้สนามเด็กเล่นเราจะได้ผลลัพธ์ดังนี้ -

Swift 4 Functions
Types and its Usage

ฟังก์ชันข้างต้นถูกประกาศให้เป็นฟังก์ชันโมฆะโดยไม่มีอาร์กิวเมนต์และไม่มีค่าส่งคืน

การใช้ประเภทฟังก์ชัน

ฟังก์ชันจะถูกส่งผ่านก่อนด้วยอาร์กิวเมนต์ประเภทจำนวนเต็มจำนวนลอยหรือสตริงจากนั้นจะส่งผ่านเป็นค่าคงที่หรือตัวแปรไปยังฟังก์ชันดังที่กล่าวไว้ด้านล่าง

var addition: (Int, Int) -> Int = sum

ผลรวมคือชื่อฟังก์ชันที่มีตัวแปรจำนวนเต็ม 'a' และ 'b' ซึ่งตอนนี้ประกาศเป็นตัวแปรสำหรับการเพิ่มชื่อฟังก์ชัน ต่อจากนี้ทั้งฟังก์ชันการบวกและการรวมจะมีอาร์กิวเมนต์จำนวนเท่ากันที่ประกาศเป็นประเภทข้อมูลจำนวนเต็มและยังส่งคืนค่าจำนวนเต็มเป็นการอ้างอิง

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")

เมื่อเรารันโปรแกรมข้างต้นโดยใช้สนามเด็กเล่นเราจะได้ผลลัพธ์ดังนี้ -

Result: 129

ประเภทฟังก์ชันเป็นประเภทพารามิเตอร์และประเภทผลตอบแทน

นอกจากนี้เรายังสามารถส่งผ่านฟังก์ชันตัวเองเป็นประเภทพารามิเตอร์ไปยังฟังก์ชันอื่นได้

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")

func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
   print("Result: \(addition(a, b))")
}
another(sum, 10, 20)

เมื่อเรารันโปรแกรมข้างต้นโดยใช้สนามเด็กเล่นเราจะได้ผลลัพธ์ดังนี้ -

Result: 129
Result: 30

ฟังก์ชันที่ซ้อนกัน

ฟังก์ชันที่ซ้อนกันให้สิ่งอำนวยความสะดวกในการเรียกใช้ฟังก์ชันภายนอกโดยเรียกใช้ฟังก์ชันภายใน

func calcDecrement(forDecrement total: Int) -> () -> Int {
   var overallDecrement = 0
   func decrementer() -> Int {
      overallDecrement -= total
      return overallDecrement
   }
   return decrementer
}

let decrem = calcDecrement(forDecrement: 30)
print(decrem())

เมื่อเรารันโปรแกรมข้างต้นโดยใช้สนามเด็กเล่นเราจะได้ผลลัพธ์ดังนี้ -

-30