วิธี Parametrize เทียบกับตัวแปรทั่วโลก

ฉันมีคำถามง่าย ๆ ที่หลอกหลอนฉันซักพักเมื่อรหัสของฉันเริ่มขึ้น

พารามิเตอร์ควรถูกแทนที่ด้วยตัวแปรโกลบอลเมื่อพวกเขาผ่านเส้นทางยาวของการเรียกฟังก์ชันที่ซ้อนกัน?

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

ให้ฉันอธิบายตัวเอง:

functionA(){
   x = something
   functionB(x)
}
functionB(x){
   functionC(x)
}
functionC(x){
   finallyDoSomethingWithX(x)
}
finallyDoSomethingWithX(x){
  x += 1 //Very dummy example ignoring pass by value, not reference.
}

แทนที่โดย:

globalX;
functionA(){
   globalX = something
   functionB()
}
...
...
...
finallyDoSomethingWithX(){
   globalX += 1
}

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

ฉันคิดว่าสิ่งนี้เกิดขึ้นกับฉันเพราะฉันไม่ได้ใช้รูปแบบการออกแบบจริง ๆ เพราะฉันเขียนโปรแกรมใน Javascript ซึ่งสำหรับฉันรู้สึกเหมือนเป็นหนึ่งในข้อตกลงกับทุกภาษาสำหรับโครงการขนาดกลาง

คำแนะนำใด ๆ รูปแบบ? ฉันสามารถเฉพาะเจาะจงมากขึ้นถ้าจำเป็น

อย่าใช้ตัวแปรทั่วโลก

อย่าให้พารามิเตอร์ผ่านกลุ่มของฟังก์ชัน!

มันยากเพราะคุณไม่ได้ใช้ตัวอย่างจริง แต่โดยปกติจะมีวิธีการที่ดีกว่า

ให้บอกว่าเรามีตัวแปรรหัสผ่านที่เราต้องใช้ในการเรียก apis ที่ใช้ inturn โดยฟังก์ชั่นระดับต่ำต่างๆ

วิธีการทั่วโลก (รหัส psudo)

var pass;

function multiply(a,b) {
   return apiMultiply(pass,a,b);
}

วิธีการผ่านพารามิเตอร์

function multiply(a,b,pass) {
    return apiMultiply(pass,a,b);
}

วิธีการวัตถุ

class math {
    var api;
    constructor(pass) {
        api = new api(pass);
    }

    function Multiply(a,b) {
        api.Multiply(a,b); //uses pass from constructor
    }
}

หลีกเลี่ยงการกลมเหมือนกาฬโรค

รหัสใด ๆ สามารถแก้ไขทั่วโลก ดังนั้นถ้าคุณมีลูกโซ่ A (x) -> B (x) -> C (x) -> ... -> Z (x) และคุณเก็บ x ไว้ใน global X และตอนนี้คุณมีลูกโซ่ A- > B-> C -> ...-> Z จากนั้นในทุกขั้นตอนของโซ่ยาวนั้นหรือในรหัสอิสระที่สมบูรณ์ใคร ๆ ก็สามารถเปลี่ยน X ได้และค่าที่ Z ใช้นั้นอาจแตกต่างอย่างสิ้นเชิงจากที่ A เริ่มต้นด้วย

มันเป็นฝันร้ายถ้าคุณต้องการให้แน่ใจว่ารหัสของคุณทำในสิ่งที่ควรทำหรือทำในสิ่งที่คุณคิด