การทำความเข้าใจขอบเขตตัวแปรและการเชื่อมโยงออบเจกต์ใน Ruby

ขอบเขตคือแนวคิดที่สำคัญสำหรับนักพัฒนา Ruby ทุกคน

ทำไม?

เพราะเป็นที่มาของข้อความแสดงข้อผิดพลาดและความสับสนมากมาย

ขอบเขตคืออะไร

ขอบเขตหมายถึงตัวแปรที่มีอยู่ ณ จุดใดเวลาหนึ่ง

ตัวแปรชนิดต่างๆ มีขอบเขตที่แตกต่างกัน

ขอบเขตสามารถแคบมาก (ตัวแปรท้องถิ่น) หรือ กว้างมาก (ตัวแปรทั่วโลก) .

คุณต้องการใช้ขอบเขตที่แคบที่สุดเพื่อหลีกเลี่ยงปัญหาการกลายพันธุ์และการชนกันของชื่อ

ต่อไปนี้เป็นรายการ ตัวอย่าง ว่าขอบเขตส่งผลต่อรหัส Ruby ของคุณอย่างไร

ขอบเขตตัวแปรท้องถิ่น

ตัวแปรโลคัลมีขอบเขตที่แคบที่สุด

โดยเฉพาะอย่างยิ่ง ตัวแปรโลคัลที่กำหนดไว้ภายในเมธอดจะไม่มีอยู่อีกต่อไปหลังจากที่เมธอดส่งคืน

นี่คือตัวอย่าง :

a = 50

def apple
  a = 100

  puts a
end

คุณคิดอย่างไรกับ apple จะพิมพ์ไหม

นี่คือคำตอบ :

เมื่อคุณโทรหา apple มันจะพิมพ์ 100 . เสมอ .

ความจริงที่ว่า a ถูกกำหนด นอกวิธี เป็น 50 ไม่มีผลกระทบต่อ a ตัวแปร ภายในวิธีการ .

เป็นตัวแปรที่แตกต่างกัน

คุณสามารถคิดว่าขอบเขตเป็นฟองสบู่ …

นี่เป็นครั้งแรก a = 50 อยู่ในฟองเดียว เมื่อคุณเรียกเมธอด หรือเมธอดใดๆ คุณจะป้อนบับเบิลว่างใหม่

คุณไม่ได้นำตัวแปรท้องถิ่นมาทับฟองใหม่

และเมื่อวิธีการถึงจุดสิ้นสุด…

ฟองสบู่แตก

ตัวแปรภายในลูกโป่งหายไปและคุณไม่สามารถเข้าถึงได้

นั่นคือวิธีการทำงานของตัวแปรท้องถิ่น

ขอบเขตตัวแปรอินสแตนซ์

ตัวแปรอินสแตนซ์มีขอบเขตที่กว้างขึ้น

โดยเฉพาะใช้สำหรับแชร์ข้อมูลภายในวัตถุ Ruby

นี่คือตัวอย่าง :

class Fruit
  def more_juice
    @quantity = 100
  end

  def less_juice
    @quantity = 50
  end
end

ในตัวอย่างนี้ @quantity เป็นตัวแปรเดียวกันสำหรับทั้ง more_juice &less_juice วิธีการ

เป็นค่าที่ใช้ร่วมกันระหว่างวิธีต่างๆ

แต่นอกคลาสนี้และแม้แต่ใน Fruit . ที่แตกต่างกัน วัตถุ @quantity จะแตกต่างออกไป

ตัวอย่าง :

orange = Fruit.new
apple  = Fruit.new

orange.more_juice
apple.less_juice

ทุกอ็อบเจ็กต์มีชุดของตัวแปรอินสแตนซ์ของตัวเอง

ในตัวอย่างนี้ orange กำลังจะมี @quantity จาก 100 และ apple กำลังจะมี @quantity จาก 50

ก็เหมือนกับคนละชื่อ อายุ ประเทศ ฯลฯ

ขอบเขตทำงานอย่างไรในบล็อก

บล็อกนั้นน่าสนใจมากเมื่อพูดถึงขอบเขต

หากเราทำตามการเปรียบเทียบแบบฟองอีกครั้ง สิ่งที่บล็อกทำคือดึงตัวแปรท้องถิ่นจากฟองสบู่ปัจจุบัน .

คุณสามารถเข้าถึงและเปลี่ยนแปลงได้

ตัวอย่าง :

a = []

3.times { a << 1 }

p a
# [1, 1, 1]

แต่...

ฟองอากาศยังคงปรากฏขึ้น โดยเอาตัวแปรในเครื่องใหม่ที่สร้างขึ้นภายในบล็อกออก

ไม่น่าสนใจเหรอ?

นี่คือตัวอย่างที่ฉันหมายถึง :

1.times { b = [1,2,3] }

b
# NameError

ไม่เพียงเท่านั้น บล็อกยังนำฟองสบู่ติดตัวไป ณ จุดที่สร้างขึ้นด้วย

เอฟเฟกต์ที่เรียกว่า "การปิด" .

โปรดจำไว้ว่า "ฟองสบู่" นี้เป็นชุดของตัวแปรทั้งหมดที่สามารถเข้าถึงได้ ณ จุดใดจุดหนึ่งในซอร์สโค้ด

มันคือขอบเขตนั่นเอง ห่อหุ้มเป็นวัตถุ

เราเรียกสิ่งนี้ว่า Binding ในทับทิม

วิธีใช้การผูกทับทิม

อีกแนวคิดหนึ่งที่ฉันต้องการแบ่งปันกับคุณในบทความนี้คือเกี่ยวกับการผูก

คุณสามารถบันทึกฟองอากาศทั้งหมดที่เรากำลังพูดถึงในวัตถุ Ruby ซึ่งเป็นวัตถุของ Binding ชั้นเรียน

ตัวอย่าง :

def banana
  a = 100

  binding
end

banana.class
# Binding

วัตถุที่มีผลผูกพันนี้คือฟองสบู่

คุณสามารถมองเข้าไปในฟองสบู่และดูว่ามีอะไรอยู่ในนั้น

ตัวอย่าง :

banana.send(:local_variables)
# [:a]

แล้วขอบเขตของ Rails คืออะไร

ขอบเขตใน Rails แตกต่างจากขอบเขตใน Ruby

แล้วขอบเขตใน Rails คืออะไร

เป็นวิธีการตั้งชื่อคิวรีฐานข้อมูลแบบกำหนดเอง ซึ่งประกอบด้วย ActiveRecord วิธีการ

นี่คือตัวอย่าง :

class User < ApplicationRecord
  scope(:with_email) { where.not(email: nil) }
end

User.with_email

อย่าสับสนกับแนวคิดของขอบเขตใน Ruby 🙂

สรุป

คุณได้เรียนรู้เกี่ยวกับขอบเขตและการผูกวัตถุใน Ruby แล้ว!

จำไว้ว่า ขอบเขตกำหนดตัวแปรที่คุณสามารถเข้าถึงได้ ณ เวลาใดเวลาหนึ่ง

เหมือนกับฟองสบู่ ตัวแปรในเครื่องมีฟองของตัวเอง ในขณะที่ออบเจ็กต์ใช้ฟองอื่นร่วมกันสำหรับตัวแปรอินสแตนซ์

ขอบคุณสำหรับการอ่าน