แนวทางปฏิบัติที่เป็นที่ยอมรับทั่วไปเกี่ยวกับการจัดระเบียบโค้ดใน JavaScript [ปิด]


561

เนื่องจากเฟรมเวิร์ก JavaScript อย่าง jQuery ทำให้เว็บแอปพลิเคชั่นฝั่งไคลเอ็นต์สมบูรณ์ยิ่งขึ้นและทำงานได้มากขึ้นฉันเริ่มสังเกตเห็นปัญหาหนึ่ง ...

คุณจัดการเรื่องนี้เป็นอย่างไรในโลก

  • ใส่เครื่องมือจัดการทั้งหมดของคุณไว้ในที่เดียวและเขียนฟังก์ชั่นสำหรับกิจกรรมทั้งหมดได้หรือไม่
  • สร้างฟังก์ชั่น / คลาสเพื่อห่อฟังก์ชั่นทั้งหมดของคุณ?
  • เขียนอย่างบ้าคลั่งและหวังว่ามันจะออกมาดีที่สุด?
  • ยอมแพ้และรับอาชีพใหม่?

ฉันพูดถึง jQuery แต่จริงๆแล้วรหัส JavaScript ใด ๆ โดยทั่วไป ฉันพบว่าเมื่อบรรทัดต่อบรรทัดเริ่มกองพะเนินมันก็ยากที่จะจัดการไฟล์สคริปต์หรือค้นหาสิ่งที่คุณกำลังมองหา อาจเป็นสัญลักษณ์ที่ยิ่งใหญ่ที่สุดที่ฉันเคยพบมีหลายวิธีในการทำสิ่งเดียวกันมันยากที่จะรู้ว่าอันไหนเป็นแนวทางปฏิบัติที่ดีที่สุดในปัจจุบันที่ยอมรับกันโดยทั่วไป

มีคำแนะนำทั่วไปเกี่ยวกับวิธีที่ดีที่สุดในการรักษาไฟล์. jsของคุณให้สวยงามและเรียบร้อยเหมือนกับแอพพลิเคชั่นอื่น ๆ ของคุณหรือไม่? หรือนี่เป็นเพียงเรื่องของ IDE หรือไม่? มีตัวเลือกที่ดีกว่าอยู่ที่นั่นไหม?


แก้ไข

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

คำถามของฉันคืออะไรวิธีปฏิบัติที่ดีที่สุดในปัจจุบันที่ยอมรับกันทั่วไปในการจัดระเบียบรหัสจริงของคุณคืออะไร? คุณมีวิธีอะไรหรือแม้กระทั่งวิธีที่แนะนำในการโต้ตอบกับองค์ประกอบของหน้าและสร้างโค้ดที่สามารถนำมาใช้ซ้ำได้ซึ่งไม่ขัดแย้งกัน

บางคนมีการระบุnamespacesซึ่งเป็นความคิดที่ดี มีวิธีอื่นใดอีกที่เกี่ยวข้องกับองค์ประกอบต่างๆในหน้าเว็บและรักษารหัสให้เป็นระเบียบและเรียบร้อย?


ใครบางคนที่ใช้เวลาพูดเกี่ยวกับการจัดระเบียบโค้ดเองไม่ใช่แค่ "เครื่องมือ" ที่เขาใช้ในการเชื่อมและบีบอัดไฟล์ JS ของเขา: stackoverflow.com/questions/16736483/…
Adrien Be

คำตอบ:


183

มันจะดีกว่านี้ถ้า javascript มีเนมสเปซอยู่ภายใน แต่ฉันพบว่าการจัดระเบียบอย่างดัสตินดิแอซอธิบายที่นี่ช่วยฉันได้มาก

var DED = (function() {

    var private_var;

    function private_method()
    {
        // do stuff here
    }

    return {
        method_1 : function()
            {
                // do stuff here
            },
        method_2 : function()
            {
                // do stuff here
            }
    };
})();

ฉันใส่ "namespaces" ที่แตกต่างกันและบางครั้งแต่ละคลาสจะแยกไฟล์ โดยปกติฉันเริ่มต้นด้วยไฟล์เดียวและเมื่อคลาสหรือเนมสเปซมีขนาดใหญ่พอที่จะรับประกันได้ฉันแยกมันออกเป็นไฟล์ของตัวเอง การใช้เครื่องมือเพื่อรวมไฟล์ทั้งหมดของคุณเพื่อการผลิตเป็นความคิดที่ยอดเยี่ยมเช่นกัน


24
ฉันมักจะอ้างถึงว่าเป็น "วิธีคร็อกฟอร์ด" +1 จากฉัน
Matt Briggs

4
คุณยังสามารถไปต่อได้อีกเล็กน้อย ดูลิงค์นี้: wait-till-i.com/2007/08/22/…
MKroehnert

4
@MattBriggs เรียกอย่างอื่นและมันจะขึ้นอยู่กับmodule pattern IIFE pattern
Adrien เป็น

คุณไม่ต้องการส่งออกคลาสหรือไม่? วัตถุถูกสร้างขึ้นจากภายนอกโมดูลดังกล่าวอย่างไร หรือควรจะมีวิธีการcreateNewSomething()ในวัตถุกลับดังนั้นการสร้างวัตถุเกิดขึ้นเพียงอย่างเดียวในโมดูล? หืมม ... ฉันคาดหวังว่าคลาส (ผู้สร้าง) จะมองเห็นได้จากภายนอก
robsch

@robsch ตัวอย่างของเขาไม่ใช้พารามิเตอร์ใด ๆ แต่ส่วนใหญ่จะ ดูตัวอย่างของฉันที่นี่สำหรับวิธีการทำสิ่งนี้โดยทั่วไป (TypeScript แต่ 99% เหมือนกัน): repl.it/@fatso83/Module-Pattern-in-TypeScript
oligofren

88

ฉันพยายามหลีกเลี่ยงการรวม Javascript ด้วย HTML รหัสทั้งหมดถูกห่อหุ้มในคลาสและแต่ละชั้นอยู่ในไฟล์ของตัวเอง สำหรับการพัฒนาฉันมีแท็ก <script> แยกเพื่อรวมไฟล์ js แต่ละไฟล์ แต่จะถูกรวมเข้ากับแพ็คเกจที่ใหญ่กว่าสำหรับการผลิตเพื่อลดค่าใช้จ่ายของคำขอ HTTP

โดยทั่วไปฉันจะมีไฟล์ js 'main' หนึ่งไฟล์สำหรับแต่ละแอปพลิเคชัน ดังนั้นถ้าฉันเขียนแอปพลิเคชั่น "สำรวจ" ฉันจะมีไฟล์ js ชื่อ "survey.js" สิ่งนี้จะมีจุดเข้าใช้งานในรหัส jQuery ฉันสร้างการอ้างอิง jQuery ระหว่างการสร้างอินสแตนซ์จากนั้นส่งต่อไปยังวัตถุของฉันเป็นพารามิเตอร์ ซึ่งหมายความว่าคลาส javascript นั้น 'บริสุทธิ์' และไม่มีการอ้างอิงใด ๆ กับรหัส CSS หรือชื่อคลาส

// file: survey.js
$(document).ready(function() {
  var jS = $('#surveycontainer');
  var jB = $('#dimscreencontainer');
  var d = new DimScreen({container: jB});
  var s = new Survey({container: jS, DimScreen: d});
  s.show();
});

ฉันยังพบว่ารูปแบบการตั้งชื่อมีความสำคัญต่อความสามารถในการอ่าน ตัวอย่างเช่น: ฉันเติม 'j' ให้กับอินสแตนซ์ jQuery ทั้งหมด

ในตัวอย่างข้างต้นมีคลาสที่เรียกว่า DimScreen (สมมติว่านี่ทำให้หน้าจอมืดลงและปรากฏขึ้นในกล่องการแจ้งเตือน) มันต้องการองค์ประกอบ div ที่สามารถขยายให้ครอบคลุมหน้าจอแล้วเพิ่มกล่องการแจ้งเตือนดังนั้นฉันจึงผ่านวัตถุ jQuery jQuery มีแนวคิดของปลั๊กอิน แต่ดูเหมือนว่าจะมีข้อ จำกัด (เช่นอินสแตนซ์ไม่ถาวรและไม่สามารถเข้าถึงได้) โดยไม่มีอัพไซด์จริง ดังนั้นคลาส DimScreen จะเป็นคลาสจาวาสคริปต์มาตรฐานที่เพิ่งเกิดขึ้นเมื่อใช้ jQuery

// file: dimscreen.js
function DimScreen(opts) { 
   this.jB = opts.container;
   // ...
}; // need the semi-colon for minimizing!


DimScreen.prototype.draw = function(msg) {
  var me = this;
  me.jB.addClass('fullscreen').append('<div>'+msg+'</div>');
  //...
};

ฉันได้สร้างแอปพลิเคชั่นที่ค่อนข้างซับซ้อนโดยใช้วิธีนี้


15
ฉันพบว่าการใช้$เป็นคำนำหน้าชื่อตัวแปรเป็นวิธีปฏิบัติทั่วไป แต่ฉันอาจผิด ดังนั้น$s = $('...')แทนที่จะjS = $('...')เป็นเรื่องของการตั้งค่าฉันเดา แม้ว่าที่น่าสนใจเนื่องจากสัญกรณ์ฮังการีเป็นความคิดที่จะมีกลิ่นรหัส มันแปลกที่การประชุม / การกำหนดค่ารหัส JavaScript ของฉันแตกต่างจากการประชุม C # / Java ของฉัน
jamiebarrow

9
@jamie มันไม่ได้เป็นกลิ่นรหัสในกรณีนี้มันเป็นได้อย่างแม่นยำหนึ่งในไม่กี่กรณีที่ฮังการีเป็นดี คุณอาจต้องการที่จะอ่านนี้
Dan Abramov

3
@DanAbramov ขอบคุณสำหรับลิงค์ ฉันต้องอ่านบล็อกทั้งหมดของ Joel จริง ๆ เขาอธิบายสิ่งต่าง ๆ ได้ดี สมควรได้รับชื่อเสียง / ชื่อเสียงที่เขามีอย่างแน่นอน ฉันจะอ้างถึงSystems Hungarianเป็นกลิ่นรหัสและApps Hungarianเป็นการปฏิบัติจากนี้ :)
jamiebarrow

ฉันเดาในโลก C # มันอาจเป็นบทความที่ยอดเยี่ยมในการส่งเสริมการใช้varตอนนี้ที่ฉันคิดเกี่ยวกับมัน ข้อโต้แย้งส่วนใหญ่ที่มีต่อการใช้varคือที่ที่คุณจะไม่แน่ใจเกี่ยวกับ 'ชนิด' ของสิ่งที่ถูกส่งคืน แต่ฉันเดาว่าข้อโต้แย้งนั้นน่าจะเป็นการต่อต้านที่ไม่รู้ว่า 'คลาส' ของสิ่งที่ส่งคืน หากใช้แอพ Hungarian คุณไม่ควรกังวลเช่นนั้น ... น่าสนใจ
jamiebarrow

3
@Marnen: ฉันเห็นประเด็นของคุณแล้ว แต่มันก็ไม่มีประโยชน์อะไรที่จะเป็นแนวทางแก่โปรแกรมเมอร์ คำนำหน้า $ เตือนฉันว่ามันคืออะไรเมื่ออ่านรหัสของฉันในภายหลังและช่วยให้เข้าใจได้เร็วขึ้น
Sean

39

คุณสามารถแยกสคริปต์ของคุณออกเป็นไฟล์แยกต่างหากเพื่อการพัฒนาจากนั้นสร้างรุ่น "ปล่อย" ซึ่งคุณจะรวมสคริปต์ทั้งหมดเข้าด้วยกันแล้วเรียกใช้YUI Compressorหรือสิ่งที่คล้ายกัน


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

2
การรวบรวม @DOK ควรมีการตัดตอนสิ่งที่ไม่ได้ใช้
aehlke

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

27

แรงบันดาลใจจากการโพสต์ก่อนหน้านี้ผมทำสำเนาของRakefileและผู้ขายไดเรกทอรีกระจายกับWysiHat (ก RTE กล่าวโดยการเปลี่ยนแปลง) และทำให้การปรับเปลี่ยนไม่กี่ที่จะรวมถึงรหัสตรวจสอบกับJSLintและ minification กับยูอิคอมเพรสเซอร์

แนวคิดคือการใช้Sprockets (จาก WysiHat) เพื่อรวม JavaScript หลาย ๆ อันไว้ในไฟล์เดียวตรวจสอบไวยากรณ์ของไฟล์ที่ผสานด้วย JSLint และย่อด้วย YUI Compressor ก่อนการแจกจ่าย

ข้อกำหนดเบื้องต้น

  • Java Runtime
  • อัญมณีทับทิมและเรค
  • คุณควรรู้วิธีใส่ JAR ไว้ในClasspath

ตอนนี้ทำ

  1. ดาวน์โหลดแรดและวาง JAR ("js.jar") ใน classpath ของคุณ
  2. ดาวน์โหลดYUI Compressorและวาง JAR (build / yuicompressor-xyz.jar) ไว้ใน classpath ของคุณ
  3. ดาวน์โหลดWysiHatและคัดลอกไดเรกทอรี "ผู้ขาย" ไปยังรากของโครงการ JavaScript ของคุณ
  4. ดาวน์โหลดJSLint for Rhinoและวางไว้ในไดเรกทอรี "ผู้ขาย"

ตอนนี้สร้างไฟล์ชื่อ "Rakefile" ในไดเรกทอรีรากของโครงการ JavaScript และเพิ่มเนื้อหาต่อไปนี้:

require 'rake'

ROOT            = File.expand_path(File.dirname(__FILE__))
OUTPUT_MERGED   = "final.js"
OUTPUT_MINIFIED = "final.min.js"

task :default => :check

desc "Merges the JavaScript sources."
task :merge do
  require File.join(ROOT, "vendor", "sprockets")

  environment  = Sprockets::Environment.new(".")
  preprocessor = Sprockets::Preprocessor.new(environment)

  %w(main.js).each do |filename|
    pathname = environment.find(filename)
    preprocessor.require(pathname.source_file)
  end

  output = preprocessor.output_file
  File.open(File.join(ROOT, OUTPUT_MERGED), 'w') { |f| f.write(output) }
end

desc "Check the JavaScript source with JSLint."
task :check => [:merge] do
  jslint_path = File.join(ROOT, "vendor", "jslint.js")

  sh 'java', 'org.mozilla.javascript.tools.shell.Main',
    jslint_path, OUTPUT_MERGED
end

desc "Minifies the JavaScript source."
task :minify => [:merge] do
  sh 'java', 'com.yahoo.platform.yui.compressor.Bootstrap', '-v',
    OUTPUT_MERGED, '-o', OUTPUT_MINIFIED
end

หากคุณทำทุกอย่างถูกต้องคุณควรจะสามารถใช้คำสั่งต่อไปนี้ในคอนโซลของคุณ:

  • rake merge - เพื่อรวมไฟล์ JavaScript ที่แตกต่างกันไว้ในที่เดียว
  • rake check- เพื่อตรวจสอบไวยากรณ์ของรหัสของคุณ (นี่เป็นภารกิจเริ่มต้นดังนั้นคุณสามารถพิมพ์ได้rake)
  • rake minify - เพื่อเตรียมเวอร์ชันย่อของรหัส JS ของคุณ

ในการรวมแหล่งที่มา

เมื่อใช้ Sprockets ตัวประมวลผลล่วงหน้าของ JavaScript คุณสามารถรวม (หรือrequire) ไฟล์ JavaScript อื่น ๆ ได้ ใช้ไวยากรณ์ต่อไปนี้เพื่อรวมสคริปต์อื่น ๆ จากไฟล์เริ่มต้น (ชื่อ "main.js" แต่คุณสามารถเปลี่ยนได้ใน Rakefile):

(function() {
//= require "subdir/jsfile.js"
//= require "anotherfile.js"

    // some code that depends on included files
    // note that all included files can be in the same private scope
})();

แล้ว ...

ดู Rakefile ที่มาพร้อมกับ WysiHat เพื่อตั้งค่าการทดสอบหน่วยอัตโนมัติ สิ่งที่ดี :)

และตอนนี้สำหรับคำตอบ

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

วิธีการแก้ไขปัญหาของฉันคือการทำโมเดลเชิงวัตถุให้มากที่สุดเท่าที่จะทำได้และแยกการใช้งานออกเป็นไฟล์ต่าง ๆ จากนั้นตัวจัดการควรสั้นที่สุด ตัวอย่างของListซิงเกิลนั้นก็ดีเช่นกัน

และเนมสเปซ ... ก็สามารถเลียนแบบได้ด้วยโครงสร้างวัตถุที่ลึกกว่า

if (typeof org === 'undefined') {
    var org = {};
}

if (!org.hasOwnProperty('example')) {
    org.example = {};
}

org.example.AnotherObject = function () {
    // constructor body
};

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


18

การจัดระเบียบรหัสต้องการการรับรองมาตรฐานและเอกสารคู่มือ:
1. รหัสเนมสเปซสำหรับไฟล์แบบฟิสิคัล

Exc = {};


2. คลาสกลุ่มในเนมสเปซเหล่านี้จาวาสคริปต์;
3. ตั้งค่าต้นแบบหรือฟังก์ชันหรือคลาสที่เกี่ยวข้องเพื่อแสดงวัตถุในโลกแห่งความจริง

Exc = {};
Exc.ui = {};
Exc.ui.maskedInput = function (mask) {
    this.mask = mask;
    ...
};
Exc.ui.domTips = function (dom, tips) {
    this.dom = gift;
    this.tips = tips;
    ...
};


4. ตั้งค่าอนุสัญญาเพื่อปรับปรุงรหัส ตัวอย่างเช่นจัดกลุ่มฟังก์ชันภายในทั้งหมดหรือวิธีการในแอตทริบิวต์ class ของประเภทวัตถุ

Exc.ui.domTips = function (dom, tips) {
    this.dom = gift;
    this.tips = tips;
    this.internal = {
        widthEstimates: function (tips) {
            ...
        }
        formatTips: function () {
            ...
        }
    };
    ...
};


5. จัดทำเอกสารของเนมสเปซ, คลาส, วิธีการและตัวแปร ในกรณีที่จำเป็นต้องพูดคุยถึงรหัสบางส่วน (บางสถาบันการเงินและ Fors พวกเขามักจะใช้ตรรกะที่สำคัญของรหัส)

/**
  * Namespace <i> Example </i> created to group other namespaces of the "Example".  
  */
Exc = {};
/**
  * Namespace <i> ui </i> created with the aim of grouping namespaces user interface.
  */
Exc.ui = {};

/**
  * Class <i> maskdInput </i> used to add an input HTML formatting capabilities and validation of data and information.
  * @ Param {String} mask - mask validation of input data.
  */
Exc.ui.maskedInput = function (mask) {
    this.mask = mask;
    ...
};

/**
  * Class <i> domTips </i> used to add an HTML element the ability to present tips and information about its function or rule input etc..
  * @ Param {String} id - id of the HTML element.
  * @ Param {String} tips - tips on the element that will appear when the mouse is over the element whose identifier is id <i> </i>.
  */
  Exc.ui.domTips = function (id, tips) {
    this.domID = id;
    this.tips = tips;
    ...
};


นี่เป็นเพียงเคล็ดลับ แต่ก็มีส่วนช่วยอย่างมากในการจัดระเบียบโค้ด จำไว้ว่าคุณต้องมีวินัยในการประสบความสำเร็จ!


13

การปฏิบัติตามหลักการออกแบบ OO ที่ดีและรูปแบบการออกแบบจะช่วยให้รหัสของคุณบำรุงรักษาและเข้าใจได้ง่าย แต่หนึ่งในสิ่งที่ดีที่สุดที่ฉันค้นพบเมื่อไม่นานมานี้คือสัญญาณและช่องเสียบเผยแพร่ / สมัครสมาชิก ดูที่http://markdotmeyer.blogspot.com/2008/09/jquery-publish-subscribe.html สำหรับการติดตั้ง jQuery แบบง่าย ๆ

แนวคิดนี้ใช้ในภาษาอื่นเพื่อการพัฒนา GUI เมื่อสิ่งสำคัญเกิดขึ้นที่ใดที่หนึ่งในรหัสของคุณคุณจะเผยแพร่เหตุการณ์สังเคราะห์ทั่วโลกซึ่งวิธีอื่นในวัตถุอื่น ๆ อาจสมัครรับ ทำให้สามารถแยกวัตถุได้อย่างดีเยี่ยม

ฉันคิดว่า Dojo (และ Prototype?) มีเทคนิคนี้ในตัว

ดูเพิ่มเติมสัญญาณและช่องคืออะไร


ฉันทำสิ่งนี้ใน jQuery JS มีรูปแบบเหตุการณ์ในตัวดังนั้นคุณไม่ต้องการการสนับสนุนกรอบงานมากนัก
Marnen Laibow-Koser


11

Dojo มีระบบโมดูลตั้งแต่วันแรก ในความเป็นจริงแล้วถือว่าเป็นรากฐานที่สำคัญของ Dojo กาวที่ยึดติดไว้ด้วยกัน:

การใช้โมดูล Dojo บรรลุวัตถุประสงค์ดังต่อไปนี้:

  • เนมสเปซสำหรับรหัส Dojo และรหัสที่กำหนดเอง ( dojo.declare()) - ไม่สร้างมลภาวะพื้นที่ส่วนกลางอยู่ร่วมกับไลบรารีอื่นและรหัสที่ไม่ทราบของผู้ใช้ Dojo
  • การโหลดโมดูลแบบซิงโครนัสหรือแบบอะซิงโครนัสตามชื่อ ( dojo.require())
  • Custom builds โดยการวิเคราะห์การพึ่งพาโมดูลเพื่อสร้างไฟล์เดี่ยวหรือกลุ่มของไฟล์ที่พึ่งพาซึ่งกันและกัน (เรียกว่าเลเยอร์) เพื่อรวมเฉพาะสิ่งที่เว็บแอปพลิเคชันของคุณต้องการ Custom builds สามารถรวมโมดูล Dojo และโมดูลที่ลูกค้าจัดหาเช่นกัน
  • การเข้าถึงตาม Dojo แบบโปร่งใส CDN และรหัสของผู้ใช้ ทั้ง AOL และ Google มี Dojo ในลักษณะนี้ แต่ลูกค้าบางคนทำเช่นนั้นสำหรับเว็บแอปพลิเคชันที่กำหนดเองเช่นกัน

9

ตรวจสอบJavasciptMVC

คุณสามารถ :

  • แยกรหัสของคุณออกเป็นแบบจำลองดูและเลเยอร์ตัวควบคุม

  • บีบอัดรหัสทั้งหมดเป็นไฟล์การผลิตเดียว

  • สร้างรหัสอัตโนมัติ

  • สร้างและเรียกใช้การทดสอบหน่วย

  • และอีกมากมาย ...

ที่ดีที่สุดคือใช้ jQuery ดังนั้นคุณสามารถใช้ประโยชน์จากปลั๊กอิน jQuery อื่น ๆ ได้เช่นกัน


ใช่ฉันเคยใช้ jmvc และมันค่อนข้างดี - เอกสารน่าจะดีกว่า
meouw

9

เจ้านายของฉันยังคงพูดถึงเวลาที่พวกเขาเขียนโค้ดแบบแยกส่วน (ภาษา C) และบ่นเกี่ยวกับวิธีการเสแสร้งรหัสในปัจจุบัน! ว่ากันว่าโปรแกรมเมอร์สามารถเขียนชุดประกอบในกรอบใดก็ได้ มีกลยุทธ์เพื่อเอาชนะการจัดระเบียบโค้ดอยู่เสมอ ปัญหาพื้นฐานคือพวกที่ใช้จาวาสคริปต์เป็นของเล่นและไม่เคยพยายามที่จะเรียนรู้

ในกรณีของฉันฉันเขียนไฟล์ js ในธีม UI หรือหน้าจอแอปพลิเคชันด้วย init_screen ที่เหมาะสม () ใช้แบบแผนการตั้งชื่อ id ที่เหมาะสมฉันแน่ใจว่าไม่มีความขัดแย้งของพื้นที่ชื่อที่ระดับองค์ประกอบราก ใน window.load ที่ไม่เป็นการรบกวนฉันผูกสิ่งต่าง ๆ ตามรหัสระดับบนสุด

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


9

ฉันประหลาดใจที่ไม่มีใครพูดถึงกรอบ MVC ฉันใช้Backbone.jsเพื่อทำให้เป็นโมดูลและแยกส่วนโค้ดของฉันและมันมีค่ามาก

มีเฟรมเวิร์กเหล่านี้ค่อนข้างน้อยและส่วนใหญ่ก็ค่อนข้างเล็กเช่นกัน ความเห็นส่วนตัวของฉันคือถ้าคุณกำลังจะเขียนมากกว่า jQuery เพียงสองสามบรรทัดสำหรับสิ่ง UI ที่ฉูดฉาดหรือต้องการแอปพลิเคชั่น Ajax ที่สมบูรณ์แบบกรอบ MVC จะทำให้ชีวิตของคุณง่ายขึ้นมาก


8

"เขียนอย่างบ้าคลั่งและหวังว่ามันจะออกมาดีที่สุด?" ฉันเคยเห็นโครงการแบบนี้ซึ่งได้รับการพัฒนาและดูแลโดยนักพัฒนาเพียง 2 คนซึ่งเป็นแอปพลิเคชันขนาดใหญ่ที่มีรหัสจาวาสคริปต์มากมาย นอกเหนือจากนั้นยังมีทางลัดที่แตกต่างกันสำหรับฟังก์ชั่น jquery ที่เป็นไปได้ทุกครั้งที่คุณนึกถึง ฉันแนะนำให้จัดระเบียบโค้ดเป็นปลั๊กอินเนื่องจากเทียบเท่ากับ jquery ของคลาสโมดูลเนมสเปซ ... และจักรวาลทั้งหมด แต่สิ่งต่าง ๆ แย่ลงมากตอนนี้พวกเขาเริ่มเขียนปลั๊กอินแทนที่ชุดของรหัส 3 บรรทัดทุกชุดที่ใช้ในโครงการ ส่วนตัวฉันคิดว่า jQuery เป็นปีศาจและไม่ควรใช้กับโปรเจ็กต์ที่มีจาวาสคริปต์มากมายเพราะมันกระตุ้นให้คุณขี้เกียจและไม่คิดว่าจะจัดระเบียบโค้ดในทางใดทางหนึ่ง ฉันควรอ่านจาวาสคริปต์มากกว่า 100 บรรทัดมากกว่าหนึ่งบรรทัดด้วยฟังก์ชั่น jQuery 40 รายการ (I ' ฉันไม่ได้ล้อเล่น) ขัดกับความเชื่อที่เป็นที่นิยมมันง่ายมากที่จะจัดระเบียบโค้ดจาวาสคริปต์ในเทียบเท่ากับเนมสเปซและคลาส นั่นคือสิ่งที่ YUI และ Dojo ทำ คุณสามารถม้วนของคุณเองถ้าคุณต้องการ ฉันพบว่าแนวทางของ YUI ดีขึ้นและมีประสิทธิภาพมากขึ้น แต่โดยปกติคุณต้องมีเครื่องมือแก้ไขที่ดีพร้อมการสนับสนุนตัวอย่างเพื่อชดเชยการตั้งชื่อ YUI หากคุณต้องการเขียนสิ่งที่มีประโยชน์


3
ฉันเห็นด้วยกับคุณเกี่ยวกับคำสั่งที่ยาวและถูกล่ามโซ่ แต่หนึ่งในส่วนที่ดีที่สุดของ jQuery คือมันทำให้ Javascript ทั้งหมดไม่ใช้ HTML คุณสามารถตั้งค่าตัวจัดการเหตุการณ์สำหรับองค์ประกอบทั้งหมดของคุณโดยไม่ต้อง "ต้องการ" เพื่อเพิ่ม ID หรือใน <whither> กิจกรรมในองค์ประกอบของคุณ เช่นเคยการใช้เครื่องมือใด ๆ ที่ไม่ดี ...
Hugoware

ฉันได้ทำงานในโครงการขนาดใหญ่ที่มีการจัดระเบียบอย่างดีใน jQuery ฉันไม่รู้ว่าทำไมคุณถึงคิดว่ามันเป็นไปในทางขององค์กร
Marnen Laibow-Koser

7

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


3
การแสดงความคิดเห็นที่ดีคือกุญแจ - ฉันดีใจที่คุณพูดดังนั้นฉันจึงไม่จำเป็นต้อง ฉันจะเพิ่มข้อตกลงการตั้งชื่อที่สอดคล้องกันกลยุทธ์การจัดเรียงที่เข้าใจได้ง่ายสำหรับตัวแปร & amp; ฟังก์ชั่นและตามที่คุณกล่าวถึงการใช้คลาสอย่างชาญฉลาดเมื่อเทียบกับซิงเกิลตัน
matt lohkamp

ไม่หากคุณต้องการความคิดเห็นรหัสของคุณโดยทั่วไปจะไม่สามารถอ่านได้เพียงพอ พยายามเขียนโค้ดที่ไม่ต้องการความคิดเห็น
Marnen Laibow-Koser

นอกจากนี้หากคุณต้องการ UML และสถานะไดอะแกรมนั่นอาจหมายความว่าสถาปัตยกรรมของคุณไม่ชัดเจนจากโค้ด downvoting
Marnen Laibow-Koser

1
@Marnen โครงการที่เป็นลายลักษณ์อักษรรวมถึงความคิดเห็นเพื่ออธิบายว่าทำไมไม่จำเป็นต้องเป็นอะไร รหัสนี้อธิบายอะไรแล้ว แต่บ่อยครั้งที่คุณต้องการบางสิ่งเพื่ออธิบายว่าทำไม Upvoting
Cypher

@Cypher โครงการที่เขียนดีมีรหัสที่ชัดเจนพอที่คุณมักจะสามารถบอกได้ว่า "ทำไม" ไม่ใช่แค่ "อะไร" ฉันไม่เชื่อถือความคิดเห็นที่จะบอกฉันว่า "ทำไม" เพราะฉันไม่รับประกันว่ามันจะซิงค์กับรหัส ปล่อยให้เอกสารรหัสตัวเอง
Marnen Laibow-Koser

6

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

ฉันใช้การจำลองเนมสเปซและการโหลดโมดูลตามส่วนของไซต์ ในการโหลดแต่ละหน้าฉันประกาศวัตถุ "vjr" และโหลดชุดของฟังก์ชั่นทั่วไปให้กับมัน (vjr.base.js) จากนั้นแต่ละหน้า HTML จะตัดสินใจว่าโมดูลใดที่ต้องการด้วยวิธีการง่ายๆ

vjr.Required = ["vjr.gallery", "vjr.comments", "vjr.favorites"];

Vjr.base.js รับแต่ละ gzipped จากเซิร์ฟเวอร์และดำเนินการ

vjr.include(vjr.Required);
vjr.include = function(moduleList) {
  if (!moduleList) return false;
  for (var i = 0; i < moduleList.length; i++) {
    if (moduleList[i]) {
      $.ajax({
        type: "GET", url: vjr.module2fileName(moduleList[i]), dataType: "script"
      });
    }
  }
};

"โมดูล" ทุกตัวมีโครงสร้างนี้:

vjr.comments = {}

vjr.comments.submitComment = function() { // do stuff }
vjr.comments.validateComment = function() { // do stuff }

// Handlers
vjr.comments.setUpUI = function() {
    // Assign handlers to screen elements
}

vjr.comments.init = function () {
  // initialize stuff
    vjr.comments.setUpUI();
}

$(document).ready(vjr.comments.init);

จากความรู้จาวาสคริปต์ที่มีอยู่อย่าง จำกัด ของฉันฉันรู้ว่าต้องมีวิธีที่ดีกว่าในการจัดการสิ่งนี้ แต่จนถึงตอนนี้มันใช้งานได้ดีสำหรับเรา


6

การจัดระเบียบรหัสของคุณในลักษณะ NameSpace ศูนย์กลาง Jquery อาจมีลักษณะดังนี้ ... และจะไม่ขัดแย้งกับ Javascript API อื่น ๆ เช่น Prototype, Ext

<script src="jquery/1.3.2/jquery.js" type="text/javascript"></script>
<script type="text/javascript">

var AcmeJQ = jQuery.noConflict(true);
var Acme = {fn: function(){}};

(function($){

    Acme.sayHi = function()
    {
        console.log('Hello');
    };

    Acme.sayBye = function()
    {
        console.log('Good Bye');
    };
})(AcmeJQ);

// Usage
//          Acme.sayHi();
// or
// <a href="#" onclick="Acme.sayHi();">Say Hello</a>


</script>

หวังว่านี่จะช่วยได้


สิ่งนี้ทำให้ฉันรู้สึกว่าเป็นสินค้าบรรทุกเล็ก ๆ น้อย ๆ jQuery.fnเป็นตัวชี้ไปjQuery.prototypeเพราะ$()จริง ๆ แล้วส่งคืนอินสแตนซ์ใหม่ของฟังก์ชันตัวสร้าง jQuery การเพิ่ม 'ปลั๊กอิน' ไปยัง jQuery หมายถึงเพียงแค่ขยายต้นแบบของมัน แต่สิ่งที่คุณกำลังทำไม่ได้เป็นเช่นนั้นและมีวิธีที่สะอาดกว่าในการทำสิ่งเดียวกันให้สำเร็จ
Adam Lassek

ฉันเชื่อว่าเขาเพียงแค่สร้างฟังก์ชั่นคงที่ ฉันจำได้ว่าเห็นมันในเอกสารของ jQuery ว่าวิธีการประกาศฟังก์ชันแบบสแตติกนี้เป็นที่ยอมรับได้
Alex Heyd

6

หลักการที่ดีของ OO + MVC จะเป็นอีกทางหนึ่งในการจัดการแอพพลิเคชั่นจาวาสคริปต์ที่ซับซ้อน

โดยทั่วไปฉันกำลังจัดแอพและจาวาสคริปต์ของฉันตามการออกแบบที่คุ้นเคยต่อไปนี้ (ซึ่งมีอยู่ทุกวันตั้งแต่การเขียนโปรแกรมเดสก์ท็อปไปจนถึง Web 2.0)

JS OO และ MVC

คำอธิบายสำหรับค่าตัวเลขบนภาพ:

  1. วิดเจ็ตที่แสดงมุมมองของแอปพลิเคชันของฉัน สิ่งนี้ควรยืดออกและแยกออกจากกันทำให้เกิดการแบ่งแยกที่ดีที่ MVC พยายามทำให้สำเร็จแทนที่จะเปลี่ยนวิดเจ็ตของฉันให้เป็นสปาเก็ตตี้โค้ด (เทียบเท่าในเว็บแอปที่ใส่ Javascript บล็อกใหญ่ใน HTML โดยตรง) แต่ละวิดเจ็ตสื่อสารผ่านผู้อื่นโดยการฟังเหตุการณ์ที่สร้างโดยวิดเจ็ตอื่น ๆ ซึ่งจะช่วยลดการเชื่อมต่อที่แข็งแกร่งระหว่างวิดเจ็ตที่อาจนำไปสู่รหัสที่ไม่สามารถจัดการได้ (จำวันที่เพิ่ม onclick ทุกที่ที่ชี้ไปยังฟังก์ชันทั่วโลก
  2. แบบจำลองวัตถุแสดงข้อมูลที่ฉันต้องการเติมในวิดเจ็ตและส่งต่อไปยังเซิร์ฟเวอร์ โดยการรวมข้อมูลเข้ากับโมเดลแอ็พพลิเคชันจะกลายเป็น agnostics รูปแบบข้อมูล ตัวอย่างเช่น: แม้ว่าโดยธรรมชาติใน Javascript โมเดลวัตถุเหล่านี้ส่วนใหญ่จะเป็นอนุกรมและดีซีเรียลไลซ์เป็น JSON ถ้าอย่างใดเซิร์ฟเวอร์ใช้ XML สำหรับการสื่อสารสิ่งที่ฉันต้องเปลี่ยนคือการเปลี่ยนเลเยอร์ serialization / deserialization และไม่จำเป็นต้องเปลี่ยนคลาสวิดเจ็ตทั้งหมด .
  3. คลาสตัวควบคุมที่จัดการตรรกะทางธุรกิจและการสื่อสารกับเซิร์ฟเวอร์ + เลเยอร์แคชเป็นครั้งคราว เลเยอร์นี้ควบคุมโปรโตคอลการสื่อสารไปยังเซิร์ฟเวอร์และใส่ข้อมูลที่จำเป็นลงในโมเดลวัตถุ
  4. คลาสจะถูกห่ออย่างเรียบร้อยในเนมสเปซที่สอดคล้องกัน ฉันแน่ใจว่าเราทุกคนรู้ว่าเนมสเปซทั่วโลกที่น่ารังเกียจอาจอยู่ใน Javascript ได้อย่างไร

ในอดีตฉันจะแยกไฟล์ออกเป็น js ของตัวเองและใช้วิธีการทั่วไปเพื่อสร้างหลักการ OO ใน Javascript ปัญหาที่ฉันพบในไม่ช้ามีหลายวิธีในการเขียน JS OO และไม่จำเป็นว่าสมาชิกในทีมทุกคนมีวิธีการเดียวกัน ในกรณีที่ทีมมีขนาดใหญ่ขึ้น (ในกรณีของฉันมากกว่า 15 คน) สิ่งนี้มีความซับซ้อนเนื่องจากไม่มีวิธีมาตรฐานสำหรับจาวาสคริปต์ที่มุ่งเน้นเชิงวัตถุ ในขณะเดียวกันฉันไม่ต้องการเขียนกรอบงานของตัวเองและทำซ้ำบางงานที่ฉันมั่นใจว่าคนฉลาดกว่าที่ฉันได้แก้ไข

jQuery นั้นยอดเยี่ยมมากอย่าง Javascript Framework และฉันชอบมาก แต่เมื่อโครงการใหญ่ขึ้นฉันต้องมีโครงสร้างเพิ่มเติมสำหรับแอปพลิเคชันเว็บของฉันโดยเฉพาะเพื่ออำนวยความสะดวกในการฝึกมาตรฐาน OO สำหรับตัวฉันเองหลังจากการทดลองหลายครั้งฉันพบว่า YUI3 Base and Widget ( http://yuilibrary.com/yui/docs/widget/และhttp://yuilibrary.com/yui/docs/base/index.html ) มีโครงสร้างพื้นฐานให้ สิ่งที่ฉันต้องการ ไม่กี่เหตุผลที่ฉันใช้พวกเขา

  1. มันให้การสนับสนุน Namespace ความต้องการที่แท้จริงสำหรับ OO และการจัดระเบียบโค้ดให้เรียบร้อย
  2. สนับสนุนแนวคิดของคลาสและวัตถุ
  3. มันให้วิธีการมาตรฐานในการเพิ่มตัวแปรอินสแตนซ์ในชั้นเรียนของคุณ
  4. สนับสนุนการขยายคลาสอย่างเรียบร้อย
  5. มันให้สร้างและ destructor
  6. มันให้เรนเดอร์และเหตุการณ์ที่มีผลผูกพัน
  7. มันมีกรอบวิดเจ็ตฐาน
  8. วิดเจ็ตแต่ละตัวสามารถสื่อสารซึ่งกันและกันโดยใช้โมเดลตามเหตุการณ์มาตรฐาน
  9. สิ่งสำคัญที่สุดคือให้วิศวกรทุกคนมีมาตรฐาน OO สำหรับการพัฒนา Javascript

ขัดกับหลายมุมมองฉันไม่จำเป็นต้องเลือกระหว่าง jQuery และ YUI3 ทั้งสองนี้สามารถอยู่ร่วมกันได้อย่างสงบสุข ในขณะที่ YUI3 มีเทมเพลต OO ที่จำเป็นสำหรับเว็บแอปที่ซับซ้อนของฉัน jQuery ยังคงให้ทีมของฉันใช้ JS Abstraction ที่ใช้งานง่ายซึ่งเราทุกคนต่างหลงรักและคุ้นเคย

การใช้ YUI3 ฉันได้สร้างรูปแบบ MVC โดยการแยกคลาสที่ขยาย Base เป็น Model คลาสที่ขยาย Widget เป็นหลักสูตร View และ off คุณมีคลาส Controller ที่ทำให้ตรรกะและการเรียกฝั่งเซิร์ฟเวอร์ที่จำเป็น

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

เพียงข้อจำกัดความรับผิดชอบฉันไม่ได้ทำงานให้กับ Yahoo! และเป็นเพียงสถาปนิกที่พยายามจัดการกับปัญหาเดียวกันกับคำถามเดิม ฉันคิดว่าถ้าใครพบกรอบการทำงานที่เทียบเท่า OO มันก็ใช้ได้เหมือนกัน ในขั้นต้นคำถามนี้ใช้กับเทคโนโลยีอื่นเช่นกัน ขอบคุณพระเจ้าสำหรับทุกคนที่มากับหลักการ OO + MVC เพื่อให้วันโปรแกรมของเราจัดการได้ง่ายขึ้น


5

ฉันใช้การจัดการแพ็กเกจของ Dojo ( dojo.requireและdojo.provide) และระบบคลาส ( dojo.declareซึ่งยังอนุญาตให้มีการสืบทอดหลายแบบง่าย) เพื่อทำให้คลาส / วิดเจ็ตของฉันทั้งหมดเป็นโมดูลแยกต่างหาก ไม่เพียง แต่จะทำให้โค้ดของคุณเป็นระเบียบ แต่ยังช่วยให้คุณขี้เกียจ / ทันเวลาในการโหลดคลาส / วิดเจ็ต


3

ไม่กี่วันที่ผ่านมาพวกที่ 37Signals เปิดตัว RTE controlพร้อมกับบิด พวกเขาสร้างห้องสมุดที่รวมไฟล์จาวาสคริปต์โดยใช้คำสั่ง pre-processor

ฉันใช้มันตั้งแต่การแยกไฟล์ JS ของฉันและจากนั้นในที่สุดก็รวมมันเป็นไฟล์เดียว ด้วยวิธีนี้ฉันสามารถแยกข้อกังวลออกและในที่สุดมีไฟล์เดียวที่ผ่านไปป์ (gzipped ไม่น้อย)

ในเทมเพลตของคุณให้ตรวจสอบว่าคุณอยู่ในโหมดการพัฒนาและรวมไฟล์แยกต่างหากหรือไม่และในการผลิตให้รวมไฟล์สุดท้าย (ซึ่งคุณจะต้อง "สร้าง" ตัวเอง)


1
getsprockets.orgเป็นลิงก์โดยตรง
Matt Gardner

3

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

$(function(){
    //Preload header images
    $('a.rollover').preload();

    //Create new datagrid
    var dGrid = datagrid.init({width: 5, url: 'datalist.txt', style: 'aero'});
});

var datagrid = {
    init: function(w, url, style){
        //Rendering code goes here for style / width
        //code etc

        //Fetch data in
        $.get(url, {}, function(data){
            data = data.split('\n');
            for(var i=0; i < data.length; i++){
                //fetching data
            }
        })
    },
    refresh: function(deep){
        //more functions etc.
    }
};

3

ฉันเริ่มใช้มันแม้แต่กับสิ่งเล็ก ๆ น้อย ๆ / พื้นฐานและมันช่วยในการรักษาโค้ดให้สะอาดและยืดหยุ่น มันคุ้มค่าที่จะใช้แม้กระทั่งการจัดการ JS ฝั่งไคลเอ็นต์อย่างง่าย
Chetan

ฉันชอบและใช้ในแอปพลิเคชันของฉัน
Andreas

2

ฉันคิดว่านี่อาจเกี่ยวข้องกับ DDD (การออกแบบที่ขับเคลื่อนด้วยโดเมน) แอปพลิเคชันที่ฉันกำลังทำงานอยู่แม้ว่าจะไม่มี API อย่างเป็นทางการ แต่ก็ให้คำแนะนำเกี่ยวกับรหัสฝั่งเซิร์ฟเวอร์ (ชื่อคลาส / ไฟล์ ฯลฯ ) ด้วยสิ่งนั้นฉันสร้างวัตถุระดับบนสุดเป็นคอนเทนเนอร์สำหรับโดเมนปัญหาทั้งหมด จากนั้นฉันได้เพิ่มเนมสเปซในที่ที่จำเป็น:

var App;
(function()
{
    App = new Domain( 'test' );

    function Domain( id )
    {
        this.id = id;
        this.echo = function echo( s )
        {
            alert( s );
        }
        return this;
    }
})();

// separate file
(function(Domain)
{
    Domain.Console = new Console();

    function Console()
    {
        this.Log = function Log( s )
        {
            console.log( s );
        }
        return this;
    }
})(App);

// implementation
App.Console.Log('foo');

2

สำหรับองค์กร JavaScript นั้นใช้สิ่งต่อไปนี้

  1. โฟลเดอร์สำหรับจาวาสคริปต์ของคุณทั้งหมด
  2. จาวาสคริปต์ในระดับหน้าได้รับไฟล์ 'เป็นของตัวเองพร้อมชื่อเดียวกันของหน้า ProductDetail.aspx จะเป็น ProductDetail.js
  3. ภายในโฟลเดอร์ javascript สำหรับไฟล์ไลบรารีฉันมีโฟลเดอร์ lib
  4. ใส่ฟังก์ชั่นห้องสมุดที่เกี่ยวข้องในโฟลเดอร์ lib ที่คุณต้องการใช้งานตลอดทั้งแอปพลิเคชันของคุณ
  5. Ajax เป็นจาวาสคริปต์ตัวเดียวที่ฉันย้ายออกไปข้างนอกโฟลเดอร์จาวาสคริปต์และได้รับเป็นโฟลเดอร์ของตัวเอง จากนั้นฉันจะเพิ่มไคลเอนต์และเซิร์ฟเวอร์ย่อยสองโฟลเดอร์
  6. โฟลเดอร์ไคลเอนต์รับไฟล์. js ทั้งหมดในขณะที่โฟลเดอร์เซิร์ฟเวอร์รับไฟล์ฝั่งเซิร์ฟเวอร์ทั้งหมด

ดีสำหรับการจัดระเบียบไฟล์ ฉันทำอย่างนั้นด้วยรหัส แต่ในที่สุดฉันก็รวบรวมรหัสของฉันใน ... สมมุติว่า dll คุณต้องมี javascript ด้วยหรือคุณจะร้องขอไฟล์ 15 js ต่อหน้า
graffic

ไม่มีอะไรผิดปกติกับการร้องขอ 15 ไฟล์ JS ต่อหน้า เบราว์เซอร์ของคุณจะแคชพวกเขาสำหรับคำขอในภายหลัง
Marnen Laibow-Koser

@ MarnenLaibow-Koser ปัญหาเดียวที่มีการร้องขอไฟล์ JS 15 ไฟล์บนหน้าหนึ่งคือจำนวนคำขอ HTTP ที่เบราว์เซอร์สามารถจัดการได้ในแต่ละครั้ง ดังนั้นการรวมเข้าเป็นไฟล์เดียวทำให้เบราว์เซอร์สามารถร้องขอไฟล์ที่จำเป็นอื่น ๆ ในเวลาเดียวกัน
iwasrobbed

เป็นเรื่องจริง แต่หลังจากสองสามครั้งแรกที่เข้าชมพวกเขาจะอยู่ในแคชของเบราว์เซอร์ดังนั้นพวกเขาจึงไม่ต้องการการเชื่อมต่อ HTTP
Marnen Laibow-Koser

2

ฉันกำลังใช้สิ่งเล็กน้อยนี้ มันให้คำสั่ง 'รวม' สำหรับทั้งแม่แบบ JS และ HTML มันกระจายความยุ่งเหยิงอย่างสมบูรณ์

https://github.com/gaperton/include.js/

$.include({
    html: "my_template.html" // include template from file...
})
.define( function( _ ){ // define module...
    _.exports = function widget( $this, a_data, a_events ){ // exporting function...
        _.html.renderTo( $this, a_data ); // which expands template inside of $this.

        $this.find( "#ok").click( a_events.on_click ); // throw event up to the caller...
        $this.find( "#refresh").click( function(){
            widget( $this, a_data, a_events ); // ...and update ourself. Yep, in that easy way.
        });
    }
});

2

คุณสามารถใช้jquery mx (ใช้ใน javascriptMVC) ซึ่งเป็นชุดของสคริปต์ที่อนุญาตให้คุณใช้รุ่นมุมมองและตัวควบคุม ฉันใช้มันในโครงการและช่วยฉันสร้างจาวาสคริปต์ที่มีโครงสร้างพร้อมขนาดสคริปต์เพียงเล็กน้อยเนื่องจากการบีบอัด นี่คือตัวอย่างคอนโทรลเลอร์:

$.Controller.extend('Todos',{
  ".todo mouseover" : function( el, ev ) {
   el.css("backgroundColor","red")
  },
  ".todo mouseout" : function( el, ev ) {
   el.css("backgroundColor","")
  },
  ".create click" : function() {
   this.find("ol").append("<li class='todo'>New Todo</li>"); 
  }
})

new Todos($('#todos'));

คุณสามารถใช้เฉพาะส่วนควบคุมของ jquerymx ถ้าคุณไม่สนใจในมุมมองและชิ้นส่วนโมเดล


1

คำถามของคุณคือคำถามที่รบกวนฉันเมื่อปลายปีที่แล้ว ความแตกต่าง - มอบรหัสให้กับนักพัฒนาใหม่ที่ไม่เคยได้ยินวิธีการของภาครัฐและเอกชน ฉันต้องสร้างอะไรที่เรียบง่าย

ผลลัพธ์ที่ได้คือเฟรมเวิร์กขนาดเล็ก (ประมาณ 1KB) ที่แปลตัวอักษรวัตถุเป็น jQuery ไวยากรณ์นั้นมองเห็นได้ง่ายกว่าในการสแกนและถ้า js ของคุณโตขึ้นมากคุณสามารถเขียนข้อความค้นหาที่ใช้ซ้ำได้เพื่อค้นหาสิ่งต่างๆเช่นตัวเลือกที่ใช้ไฟล์ที่โหลดฟังก์ชันที่ต้องใช้งาน ฯลฯ

การโพสต์กรอบเล็ก ๆ ที่นี่ไม่สามารถทำได้ดังนั้นฉันจึงเขียนโพสต์บล็อกพร้อมตัวอย่าง (ก่อนอื่นนั่นคือการผจญภัย!) คุณยินดีที่จะดู

สำหรับคนอื่น ๆ ที่นี่ด้วยไม่กี่นาทีเพื่อตรวจสอบมันฉันขอขอบคุณข้อเสนอแนะอย่างมาก!

แนะนำให้ใช้ FireFox เนื่องจากสนับสนุน toSource () สำหรับตัวอย่างแบบสอบถามวัตถุ

ไชโย!

อาดัม


0

ฉันใช้สคริปต์ที่กำหนดเองซึ่งได้รับแรงบันดาลใจจากพฤติกรรมของ Ben Nolan (ฉันไม่สามารถหาลิงก์ปัจจุบันไปที่นี้อีกต่อไปเศร้า) เพื่อจัดเก็บตัวจัดการเหตุการณ์ส่วนใหญ่ของฉัน ตัวจัดการเหตุการณ์เหล่านี้ถูกทริกเกอร์โดยองค์ประกอบ className หรือ Id ตัวอย่างเช่น ตัวอย่าง:

Behaviour.register({ 
    'a.delete-post': function(element) {
        element.observe('click', function(event) { ... });
    },

    'a.anotherlink': function(element) {
        element.observe('click', function(event) { ... });
    }

});

ฉันชอบที่จะรวมไลบรารี Javascript ของฉันไว้ส่วนใหญ่ยกเว้นที่มีพฤติกรรมทั่วโลก ผมใช้Zend Framework ของ headScript () ผู้ช่วยยึดตำแหน่งนี้ แต่คุณยังสามารถใช้จาวาสคริปต์ในการโหลดสคริปต์อื่น ๆ เกี่ยวกับการบินด้วยAjileตัวอย่างเช่น


นี่คือสิ่งที่คุณกำลังมองหา? koders.com/javascript/…
DOK

ใช่นั่นคือสิ่งนั้น! :) ดูเหมือนว่าโค้ดด้านหลังลิงค์ค่อนข้างใหม่กว่าเวอร์ชั่นที่ฉันได้รับแรงบันดาลใจ ขอบคุณสำหรับความพยายามของคุณ!
Aron Rotteveel

0

คุณไม่ได้พูดถึงภาษาฝั่งเซิร์ฟเวอร์ของคุณ หรือมากกว่านั้นอย่างชัดเจนว่าคุณกำลังใช้กรอบงานใด - ถ้ามี - บนฝั่งเซิร์ฟเวอร์

IME ฉันจัดระเบียบสิ่งต่าง ๆ บนฝั่งเซิร์ฟเวอร์และปล่อยให้มันสั่นคลอนไปยังหน้าเว็บ เฟรมเวิร์กได้รับมอบหมายให้จัดระเบียบไม่เพียง JS ที่ทุกหน้าต้องโหลดเท่านั้น แต่ยังรวมถึงชิ้นส่วน JS ที่ทำงานกับมาร์กอัปที่สร้างขึ้น ส่วนดังกล่าวที่คุณมักไม่ต้องการปล่อยออกมามากกว่าหนึ่งครั้ง - นั่นคือเหตุผลที่พวกเขาถูกแยกออกเป็นกรอบสำหรับโค้ดนั้นเพื่อดูแลปัญหานั้น :-)

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

โปรดทราบว่าไม่มีสิ่งใดที่ทำให้คุณไม่ต้องเขียน JavaScript อย่างมีประสิทธิภาพ! :-)


โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.