โคลเชอร์และขอบเขต
จับตัวแปรไว้ใช้
โคลเชอร์และขอบเขต เป็นบทเรียน Ruby Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Ruby Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Ruby Academy มีบทเรียนทั้งหมด 4 บทเรียน
การจับตัวแปรไว้
คลอเชอร์ คือฟังก์ชันที่จดจำตัวแปรจากบริเวณที่มันถูกสร้างขึ้น แม้บริเวณนั้นจะทำงานเสร็จแล้วก็ตาม Proc และแลมบ์ดาเป็นคลอเชอร์
name = "Ada"
greeter = -> { puts "Hello, #{name}" }
greeter.callตัวแปรเดินทางไปพร้อมกับคลอเชอร์
คลอเชอร์ไม่ได้คัดลอกค่า แต่เก็บการอ้างอิงแบบเชื่อมโยงไปยังตัวแปรไว้ หากเปลี่ยนตัวแปรในภายหลัง คลอเชอร์ก็จะเห็นค่าใหม่
count = 0
reader = -> { count }
count = 5
puts reader.callคลอเชอร์สามารถเปลี่ยนค่าได้
เนื่องจากการอ้างอิงยังเชื่อมโยงอยู่ คลอเชอร์จึงสามารถแก้ไขตัวแปรที่จับไว้ได้เช่นกัน
total = 0
adder = ->(n) { total += n }
adder.call(3)
adder.call(7)
puts totalตัวแปรอยู่ต่อหลังเมธอดที่ครอบอยู่
ตัวแปรที่ถูกจับไว้จะยังคงอยู่ตราบเท่าที่คลอเชอร์ยังอยู่ แม้เมธอดที่สร้างคลอเชอร์นั้นจะส่งคืนค่าไปแล้ว
def counter
n = 0
-> { n += 1 }
end
c = counter
puts c.call
puts c.call
puts c.callสถานะที่แยกจากกัน
การเรียกเมธอดสร้างค่าครั้งใหม่จะสร้างตัวแปรใหม่ ดังนั้นคลอเชอร์ที่แยกกันจึงเก็บสถานะแยกจากกัน
def counter
n = 0
-> { n += 1 }
end
a = counter
b = counter
puts a.call
puts a.call
puts b.callพารามิเตอร์ของบล็อกเป็นตัวแปรเฉพาะที่
พารามิเตอร์ที่ประกาศไว้ระหว่างเครื่องหมายไปป์จะเป็นตัวแปรเฉพาะที่ของบล็อก และจะไม่รั่วไหลออกไปภายนอก แม้ว่าจะมีตัวแปรชื่อเดียวกันอยู่แล้วก็ตาม
x = 100
[1, 2, 3].each { |x| }
puts x # still 100ตัวแปรเฉพาะที่ของบล็อก
ระบุชื่อเพิ่มเติมหลังเครื่องหมายเซมิโคลอนในเครื่องหมายไปป์ เพื่อบังคับให้ชื่อเหล่านั้นเป็นตัวแปรเฉพาะที่ของบล็อก และป้องกันไม่ให้ตัวแปรภายนอกถูกเปลี่ยนค่าโดยไม่ตั้งใจ
y = "outer"
[1].each { |i; y| y = "inner" }
puts y # unchangedการสร้างฟังก์ชันที่กำหนดค่าได้
คลอเชอร์ช่วยให้คุณใส่ค่าการกำหนดค่าไว้ในฟังก์ชันเพียงครั้งเดียว แล้วนำฟังก์ชันนั้นกลับมาใช้ซ้ำได้หลายครั้ง
def power_of(exp)
->(base) { base ** exp }
end
square = power_of(2)
cube = power_of(3)
puts square.call(5)
puts cube.call(2)คลอเชอร์ในการวนซ้ำ
ข้อผิดพลาดที่พบบ่อยคือ คลอเชอร์ที่สร้างขึ้นในลูปจะจับตัวแปร ไม่ใช่ค่าที่บันทึกไว้ ณ ขณะนั้น การสร้างคลอเชอร์ใหม่ในแต่ละรอบจะทำให้แต่ละค่าถูกจับแยกจากกัน
funcs = [1, 2, 3].map { |i| -> { i } }
puts funcs.map(&:call).inspectการห่อหุ้มสถานะส่วนตัว
คลอเชอร์สามารถซ่อนสถานะไว้เบื้องหลังฟังก์ชัน ซึ่งเป็นรูปแบบแรกเริ่มของออบเจ็กต์ ในที่นี้จะไม่สามารถเข้าถึงยอดคงเหลือได้ นอกจากผ่านแลมบ์ดาที่ส่งคืนมา
def make_account(start)
balance = start
deposit = ->(n) { balance += n }
show = -> { balance }
[deposit, show]
end
dep, show = make_account(100)
dep.call(50)
puts show.callนำทุกอย่างมาประกอบกัน
คลอเชอร์ผูกโค้ดเข้ากับบริบทที่สร้างมันขึ้นมา:
- จับการอ้างอิงแบบเชื่อมโยงไปยังตัวแปรโดยรอบ
- สถานะยังคงอยู่หลังจากเมธอดที่ครอบอยู่ส่งคืนค่า
- คลอเชอร์แต่ละตัวเก็บตัวแปรของตนเองอย่างเป็นอิสระ
def tagger(prefix)
->(text) { "[#{prefix}] #{text}" }
end
warn = tagger("WARN")
puts warn.call("low disk space")ตรวจความเข้าใจ
ทดสอบความเข้าใจเกี่ยวกับคลอเชอร์ของคุณ
ทบทวน
คุณได้เรียนรู้เรื่องคลอเชอร์และขอบเขตดังนี้:
- Proc และแลมบ์ดาจับตัวแปรโดยรอบด้วยการอ้างอิง
- สถานะที่ถูกจับไว้ยังคงอยู่นานกว่าเมธอดที่ครอบอยู่
- คลอเชอร์แต่ละตัวมีสถานะที่เป็นอิสระต่อกัน
- พารามิเตอร์ของบล็อกเป็นตัวแปรเฉพาะที่ ใช้
;สำหรับตัวแปรเฉพาะที่ของบล็อก
def stepper(by)
pos = 0
-> { pos += by }
end
s = stepper(5)
puts s.call
puts s.callคำถามที่พบบ่อย
บทเรียน “โคลเชอร์และขอบเขต” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “โคลเชอร์และขอบเขต” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Ruby Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Ruby Academy มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “โคลเชอร์และขอบเขต”
จับตัวแปรไว้ใช้ คุณปฏิบัติ Ruby Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Ruby Academy หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Ruby Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน
บทเรียน “โคลเชอร์และขอบเขต” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Ruby Academy นี้ได้ไหม
ได้ บทเรียน Ruby Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- ทบทวนบล็อก
- Proc
- แลมบ์ดา
- โคลเชอร์และขอบเขต