เว็บไซต์ JS และ SEO แบบ“ หน้าเดียว”


128

มีเครื่องมือเจ๋ง ๆ มากมายสำหรับการสร้างเว็บไซต์จาวาสคริปต์แบบ "หน้าเดียว" ที่มีประสิทธิภาพในปัจจุบัน ในความคิดของฉันสิ่งนี้ถูกต้องแล้วโดยปล่อยให้เซิร์ฟเวอร์ทำหน้าที่เป็น API (และไม่มีอะไรเพิ่มเติม) และให้ลูกค้าจัดการสิ่งที่สร้าง HTML ทั้งหมด ปัญหาของ "รูปแบบ" นี้คือการขาดการสนับสนุนเครื่องมือค้นหา ฉันสามารถคิดถึงวิธีแก้ปัญหาสองข้อ:

  1. เมื่อผู้ใช้เข้าสู่เว็บไซต์ให้เซิร์ฟเวอร์แสดงผลหน้าเว็บเหมือนกับที่ลูกค้าทำตามการนำทาง ดังนั้นถ้าฉันไปhttp://example.com/my_pathที่เซิร์ฟเวอร์โดยตรงจะทำให้สิ่งเดียวกันกับไคลเอนต์ถ้าฉัน/my_pathผ่าน pushState
  2. ให้เซิร์ฟเวอร์จัดทำเว็บไซต์พิเศษเฉพาะสำหรับบอตของเครื่องมือค้นหา หากผู้ใช้ทั่วไปเข้าชมhttp://example.com/my_pathเซิร์ฟเวอร์ควรให้เว็บไซต์เวอร์ชันใหญ่แก่ JavaScript แต่ถ้าบอตของ Google เข้าชมเซิร์ฟเวอร์ควรให้ HTML ที่น้อยที่สุดพร้อมเนื้อหาที่ฉันต้องการให้ Google จัดทำดัชนี

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

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

ดังนั้นสิ่งที่ฉันสงสัยจริงๆคือต่อไปนี้:

  • คุณนึกถึงทางออกที่ดีกว่านี้ได้ไหม?
  • อะไรคือข้อเสียของโซลูชันที่สอง? หาก Google พบว่าฉันไม่ได้ให้บริการเนื้อหาเดียวกันกับ bot ของ Google ในฐานะผู้ใช้ทั่วไปฉันจะต้องถูกลงโทษในผลการค้นหาหรือไม่?

คำตอบ:


44

ในขณะที่ # 2 อาจเป็น "ง่ายขึ้น" สำหรับคุณในฐานะนักพัฒนา แต่ให้เฉพาะการรวบรวมข้อมูลของเครื่องมือค้นหา และใช่ถ้า Google พบว่าการให้บริการเนื้อหาที่แตกต่างคุณอาจถูกลงโทษ (ฉันไม่ใช่ผู้เชี่ยวชาญในเรื่องนั้น แต่ฉันได้ยินมาว่ามันเกิดขึ้น)

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

pushStateไม่ได้เพิ่มภาระนี้ในประสบการณ์ของฉัน มันนำสิ่งที่เคยเป็นภายหลังและ "ถ้าเรามีเวลา" เพื่อระดับแนวหน้าของการพัฒนาเว็บ

สิ่งที่คุณอธิบายในตัวเลือก # 1 มักจะเป็นวิธีที่ดีที่สุด - แต่เช่นปัญหาการเข้าถึงและ SEO อื่น ๆ การทำสิ่งนี้ด้วยpushStateแอป JavaScript ที่หนักหน่วงต้องมีการวางแผนล่วงหน้าหรือจะกลายเป็นภาระที่สำคัญ ควรนำเข้าสู่หน้าและสถาปัตยกรรมแอปพลิเคชันจากจุดเริ่มต้นการติดตั้งใหม่จะทำให้เกิดความเจ็บปวดและจะทำให้เกิดการทำซ้ำเกินความจำเป็น

pushStateเมื่อเร็ว ๆ นี้ฉันได้ทำงานกับSEO และมีแอพพลิเคชั่นที่ต่างกันสองสามตัว โดยทั่วไปแล้วจะเป็นไปตามรายการ # 1 ของคุณ แต่บัญชีจะไม่ทำซ้ำ html / เทมเพลต

ข้อมูลส่วนใหญ่สามารถพบได้ในโพสต์บล็อกทั้งสองนี้:

http://lostechies.com/derickbailey/2011/09/06/test-driving-backbone-views-with-jquery-templates-the-jasmine-gem-and-jasmine-jquery/

และ

http://lostechies.com/derickbailey/2011/06/22/rendering-a-rails-partial-as-a-jquery-template/

สิ่งสำคัญของมันคือฉันใช้เทมเพลต ERB หรือ HAML (ใช้ Ruby บน Rails, Sinatra เป็นต้น) สำหรับการสร้างภาพฝั่งเซิร์ฟเวอร์ของฉันและเพื่อสร้างเทมเพลตฝั่งไคลเอนต์ที่ Backbone สามารถใช้ได้เช่นเดียวกับรายละเอียด Jasmine JavaScript ของฉัน สิ่งนี้จะตัดการทำซ้ำของมาร์กอัพระหว่างฝั่งเซิร์ฟเวอร์และฝั่งไคลเอ็นต์

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

pushStateยกตัวอย่างเช่นผมสร้างแอพลิเคชันที่มีแกลเลอรี่ภาพ หากคุณร้องขอ/images/1จากเซิร์ฟเวอร์มันจะแสดงแกลเลอรี่รูปภาพทั้งหมดบนเซิร์ฟเวอร์และส่ง HTML, CSS และ JavaScript ทั้งหมดไปยังเบราว์เซอร์ของคุณ หากคุณปิดใช้งาน JavaScript มันจะทำงานได้อย่างสมบูรณ์แบบ ทุกการกระทำที่คุณทำจะขอ URL ที่แตกต่างจากเซิร์ฟเวอร์และเซิร์ฟเวอร์จะแสดงมาร์กอัพทั้งหมดสำหรับเบราว์เซอร์ของคุณ หากคุณเปิดใช้งาน JavaScript แล้ว JavaScript จะรับ HTML ที่แสดงผลไปแล้วพร้อมกับตัวแปรที่สร้างโดยเซิร์ฟเวอร์และรับช่วงต่อจากนั้น

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

<form id="foo">
  Name: <input id="name"><button id="say">Say My Name!</button>
</form>

หลังจากเซิร์ฟเวอร์แสดงผลสิ่งนี้ JavaScript จะรับมัน (ใช้มุมมอง Backbone.js ในตัวอย่างนี้)

FooView = Backbone.View.extend({
  events: {
    "change #name": "setName",
    "click #say": "sayName"
  },

  setName: function(e){
    var name = $(e.currentTarget).val();
    this.model.set({name: name});
  },

  sayName: function(e){
    e.preventDefault();
    var name = this.model.get("name");
    alert("Hello " + name);
  },

  render: function(){
    // do some rendering here, for when this is just running JavaScript
  }
});

$(function(){
  var model = new MyModel();
  var view = new FooView({
    model: model,
    el: $("#foo")
  });
});

นี่เป็นตัวอย่างที่ง่ายมาก แต่ฉันคิดว่ามันได้รับประเด็น

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

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

แก้ไข

พิจารณาตัวอย่างที่ซับซ้อนมากขึ้นซึ่งคุณมีรายการที่จะต้องแนบ (จากความคิดเห็นด้านล่างนี้)

สมมติว่าคุณมีรายชื่อผู้ใช้ใน<ul>แท็ก เซิร์ฟเวอร์แสดงรายการนี้เมื่อเบราว์เซอร์ทำการร้องขอและผลลัพธ์จะมีลักษณะดังนี้:

<ul id="user-list">
  <li data-id="1">Bob
  <li data-id="2">Mary
  <li data-id="3">Frank
  <li data-id="4">Jane
</ul>

ตอนนี้คุณต้องวนซ้ำรายการนี้และแนบมุมมองและรูปแบบ Backbone กับแต่ละ<li>รายการ ด้วยการใช้data-idแอตทริบิวต์คุณสามารถค้นหารุ่นที่แต่ละแท็กมาจากได้อย่างง่ายดาย จากนั้นคุณจะต้องมีมุมมองคอลเลกชันและมุมมองรายการที่ฉลาดพอที่จะแนบตัวเองกับ html นี้

UserListView = Backbone.View.extend({
  attach: function(){
    this.el = $("#user-list");
    this.$("li").each(function(index){
      var userEl = $(this);
      var id = userEl.attr("data-id");
      var user = this.collection.get(id);
      new UserView({
        model: user,
        el: userEl
      });
    });
  }
});

UserView = Backbone.View.extend({
  initialize: function(){
    this.model.bind("change:name", this.updateName, this);
  },

  updateName: function(model, val){
    this.el.text(val);
  }
});

var userData = {...};
var userList = new UserCollection(userData);
var userListView = new UserListView({collection: userList});
userListView.attach();

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


กระบวนการแบบนี้ในการใช้ html ที่เซิร์ฟเวอร์แสดงผลและให้ JavaScript ของฉันเข้ามาแทนที่และรันมันเป็นวิธีที่ยอดเยี่ยมในการทำให้สิ่งต่าง ๆ สำหรับ SEO การเข้าถึงและpushStateการสนับสนุน

หวังว่าจะช่วย


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

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

22

ฉันคิดว่าคุณต้องการสิ่งนี้: http://code.google.com/web/ajaxcrawling/

นอกจากนี้คุณยังสามารถติดตั้งแบ็กเอนด์พิเศษที่ "แสดงผล" หน้าของคุณโดยการเรียกใช้จาวาสคริปต์บนเซิร์ฟเวอร์จากนั้นให้บริการแก่ google

รวมทั้งสองอย่างเข้าด้วยกันและคุณมีทางออกโดยไม่ต้องเขียนโปรแกรมสองครั้ง (ตราบใดที่แอปของคุณสามารถควบคุมได้อย่างสมบูรณ์ผ่านทางชิ้นส่วนสมอ)


จริงๆแล้วมันไม่ใช่สิ่งที่ฉันกำลังมองหา นั่นเป็นตัวแปรบางส่วนของวิธีแก้ปัญหาแรกและอย่างที่ฉันบอกไปฉันไม่พอใจกับวิธีการนี้มากนัก
user544941

2
คุณไม่ได้อ่านคำตอบทั้งหมดของฉัน คุณยังใช้แบ็กเอนด์พิเศษที่ทำให้จาวาสคริปต์สำหรับคุณ - คุณไม่ได้เขียนสองครั้ง
Ariel

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

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

17

ดังนั้นดูเหมือนว่าความกังวลหลักคือการแห้ง

  • หากคุณใช้ pushState ให้เซิร์ฟเวอร์ของคุณส่งรหัสที่แน่นอนเหมือนกันสำหรับ URL ทั้งหมด (ที่ไม่มีส่วนขยายไฟล์สำหรับแสดงรูปภาพ ฯลฯ ) "/ mydir / myfile", "/ myotherdir / myotherfile" หรือรูท "/ "- คำขอทั้งหมดได้รับรหัสที่แน่นอนเหมือนกัน คุณต้องมีเอ็นจิ้นการเขียน url ใหม่อีกครั้ง นอกจากนี้คุณยังสามารถให้บริการ html เล็กน้อยและที่เหลือสามารถมาจาก CDN ของคุณ (ใช้ require.js เพื่อจัดการการพึ่งพา - ดูhttps://stackoverflow.com/a/13813102/1595913 )
  • (ทดสอบความถูกต้องของลิงก์โดยแปลงลิงก์ไปยังรูปแบบ URL ของคุณและทดสอบการมีอยู่ของเนื้อหาโดยการค้นหาแหล่งข้อมูลแบบคงที่หรือแบบไดนามิกหากไม่ถูกต้องให้ส่งการตอบกลับ 404)
  • เมื่อคำขอไม่ได้มาจาก google bot คุณเพียงดำเนินการตามปกติ
  • หากคำขอมาจาก google bot คุณใช้ phantom.js - เบราว์เซอร์หัวขาดเว็บเบราว์เซอร์ ( "เบราว์เซอร์หัวขาดเป็นเพียงเว็บเบราว์เซอร์เต็มรูปแบบที่ไม่มีส่วนต่อประสานภาพ" ) เพื่อแสดง html และ javascript บนเซิร์ฟเวอร์และส่ง google bot html ที่ได้ ในขณะที่บ็อตทำการแยกวิเคราะห์ html มันสามารถไปยังลิงก์ / บางเพจบนเซิร์ฟเวอร์ "pushState" อื่น ๆ<a href="https://stackoverflow.com/someotherpage">mylink</a>เซิร์ฟเวอร์จะเขียน url ไปยังไฟล์แอปพลิเคชันของคุณโหลดเป็น phantom.js และ html ที่เป็นผลลัพธ์จะถูกส่งไปยัง bot และอื่น ๆ ..
  • สำหรับ html ของคุณฉันกำลังสมมติว่าคุณใช้ลิงก์ปกติกับการไฮแจ็กบางประเภท (เช่นใช้กับ backbone.js https://stackoverflow.com/a/9331734/1595913 )
  • หากต้องการหลีกเลี่ยงความสับสนกับลิงก์ใด ๆ ให้แยกรหัส api ของคุณที่แสดง json เป็นโดเมนย่อยแยกเช่น api.mysite.com
  • เพื่อปรับปรุงประสิทธิภาพคุณสามารถประมวลผลหน้าเว็บไซต์ของคุณล่วงหน้าสำหรับเครื่องมือค้นหาล่วงหน้าในช่วงนอกเวลาทำการโดยการสร้างหน้าแบบคงที่โดยใช้กลไกเดียวกันกับ phantom.js และส่งหน้าคงที่ไปยัง Google บอท การประมวลผลล่วงหน้าสามารถทำได้ด้วยแอพง่ายๆที่สามารถแยก<a>แท็ก ในกรณีนี้การจัดการ 404 นั้นง่ายกว่าเพราะคุณสามารถตรวจสอบว่าไฟล์สแตติกนั้นมีชื่อที่มีพา ธ url อยู่หรือไม่
  • ถ้าคุณใช้ #! hash bang ไวยากรณ์สำหรับการเชื่อมโยงไซต์ของคุณในสถานการณ์ที่คล้ายกันยกเว้นว่าเอ็นจิ้นเซิร์ฟเวอร์ url ที่เขียนซ้ำจะมองหา _escaped_fragment_ ใน url และจะจัดรูปแบบ URL ไปยังรูปแบบ URL ของคุณ
  • มีการรวมสองสามอย่างของ node.js กับ phantom.js บน github และคุณสามารถใช้ node.js เป็นเว็บเซิร์ฟเวอร์เพื่อสร้างเอาต์พุต html

นี่คือตัวอย่างที่ใช้ phantom.js สำหรับ seo:

http://backbonetutorials.com/seo-for-single-page-apps/

http://thedigitalself.com/blog/seo-and-javascript-with-phantomjs-server-side-rendering


4

หากคุณกำลังใช้ Rails ให้ลองปัวโรต์ มันเป็นอัญมณีที่ทำให้ตายง่าย ๆ ที่จะใช้หนวดหรือมือจับแม่แบบลูกค้าและฝั่งเซิร์ฟเวอร์

_some_thingy.html.mustacheสร้างแฟ้มในมุมมองของคุณเช่น

ฝั่งเซิร์ฟเวอร์แสดงผล:

<%= render :partial => 'some_thingy', object: my_model %>

ใส่แม่แบบของคุณสำหรับการใช้งานด้านลูกค้า:

<%= template_include_tag 'some_thingy' %>

แสดงด้านไคลเอนต์:

html = poirot.someThingy(my_model)

3

หากต้องการมุมที่แตกต่างออกไปเล็กน้อยโซลูชันที่สองของคุณจะเป็นมุมมองที่ถูกต้องในแง่ของการเข้าถึง ... คุณจะให้เนื้อหาทางเลือกแก่ผู้ใช้ที่ไม่สามารถใช้จาวาสคริปต์ (ผู้ที่มีโปรแกรมอ่านหน้าจอ ฯลฯ )

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


และใครบ้างที่พิสูจน์ว่าคุณผิด มันเป็นช่วงเวลาตั้งแต่ความคิดเห็นถูกโพสต์
jkulak

1

น่าสนใจ ฉันค้นหาวิธีแก้ปัญหาที่ใช้ได้จริง แต่ดูเหมือนว่าจะมีปัญหา

จริงๆแล้วฉันเอนตัวไปที่แนวทางที่ 2 ของคุณ:

ให้เซิร์ฟเวอร์จัดทำเว็บไซต์พิเศษเฉพาะสำหรับบอตของเครื่องมือค้นหา หากผู้ใช้ทั่วไปเยี่ยมชมhttp://example.com/my_pathเซิร์ฟเวอร์ควรให้เว็บไซต์เวอร์ชันใหญ่แก่ JavaScript แก่เขา แต่ถ้าบอตของ Google เข้าชมเซิร์ฟเวอร์ควรให้ HTML ที่น้อยที่สุดพร้อมเนื้อหาที่ฉันต้องการให้ Google จัดทำดัชนี

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

สมมติว่าคุณกำลังใช้เฟรมเวิร์ก JS ที่รองรับฟังก์ชั่น "push state" และเฟรมเวิร์กแบ็กเอนด์ของคุณคือ Ruby on Rails คุณมีเว็บไซต์บล็อกง่าย ๆ และคุณต้องการให้เสิร์ชเอนจิ้นจัดทำดัชนีบทความindexและshowหน้าทั้งหมดของคุณ

สมมติว่าคุณตั้งค่าเส้นทางไว้ดังนี้:

resources :articles
match "*path", "main#index"

ตรวจสอบให้แน่ใจว่าคอนโทรลเลอร์ฝั่งเซิร์ฟเวอร์ทุกอันแสดงเทมเพลตเดียวกันกับที่เฟรมเวิร์กฝั่งไคลเอ็นต์ของคุณต้องการเรียกใช้ (html / css / javascript / etc) หากไม่มีตัวควบคุมใดถูกจับคู่ในคำขอ (ในตัวอย่างนี้เรามีชุดการกระทำที่สงบสำหรับการArticlesController) เพียงแค่จับคู่สิ่งอื่นและแสดงเท็มเพลตและให้เฟรมเวิร์กฝั่งไคลเอ็นต์จัดการกับการกำหนดเส้นทาง ความแตกต่างเพียงอย่างเดียวระหว่างการกดปุ่มควบคุมและการกดปุ่ม wildcard matcher จะเป็นความสามารถในการแสดงเนื้อหาตาม URL ที่ถูกร้องขอไปยังอุปกรณ์ที่ปิดการใช้งาน JavaScript

จากสิ่งที่ฉันเข้าใจมันเป็นความคิดที่ดีที่จะแสดงเนื้อหาที่ไม่สามารถมองเห็นได้กับเบราว์เซอร์ ดังนั้นเมื่อ Google จัดทำดัชนีผู้คนจะผ่าน Google เพื่อเยี่ยมชมหน้าเว็บที่ระบุและไม่มีเนื้อหาใด ๆ เลยคุณอาจถูกลงโทษ สิ่งที่อยู่ในใจคือคุณแสดงเนื้อหาในdivโหนดที่คุณdisplay: noneอยู่ใน CSS

อย่างไรก็ตามฉันค่อนข้างแน่ใจว่ามันไม่สำคัญว่าคุณจะทำสิ่งนี้เพียง:

<div id="no-js">
  <h1><%= @article.title %></h1>
  <p><%= @article.description %></p>
  <p><%= @article.content %></p>
</div>

จากนั้นใช้ JavaScript ซึ่งไม่ได้รับการเรียกใช้เมื่ออุปกรณ์ที่ปิดใช้งาน JavaScript เปิดหน้า:

$("#no-js").remove() # jQuery

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

แต่เมื่อผู้ใช้เข้าชมหน้าเดียวกันและที่จริงมีการเปิดใช้งาน JavaScript ที่#no-jsโหนดจะถูกลบออกจึงไม่ถ่วงขึ้นใบสมัครของคุณ จากนั้นเฟรมเวิร์กฝั่งไคลเอ็นต์ของคุณจะจัดการการร้องขอผ่านเราเตอร์และแสดงสิ่งที่ผู้ใช้ควรเห็นเมื่อเปิดใช้งาน JavaScript

ฉันคิดว่านี่อาจเป็นเทคนิคที่ใช้ได้และใช้งานง่าย แม้ว่ามันอาจขึ้นอยู่กับความซับซ้อนของเว็บไซต์ / แอปพลิเคชันของคุณ

แม้ว่าโปรดแก้ไขให้ฉันถ้ามันไม่ใช่ แค่คิดว่าฉันจะแบ่งปันความคิดของฉัน


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

1

ใช้ NodeJS บนฝั่งเซิร์ฟเวอร์เบราว์เซอร์รหัสลูกค้าของคุณและกำหนดเส้นทางแต่ละคำขอ http (ยกเว้นสำหรับทรัพยากร HTTP แบบคงที่) uri ผ่านไคลเอนต์เซิร์ฟเวอร์เพื่อให้ 'bootsnap' ครั้งแรก (ภาพรวมของหน้าเว็บเป็นสถานะ) ใช้สิ่งที่ต้องการ jsdom เพื่อจัดการ jquery dom-ops บนเซิร์ฟเวอร์ หลังจากบูทกลับมาแล้วให้ตั้งค่าการเชื่อมต่อ websocket อาจดีที่สุดในการแยกความแตกต่างระหว่างไคลเอนต์ websocket และไคลเอนต์เซิร์ฟเวอร์โดยทำการเชื่อมต่อ wrapper บนฝั่งไคลเอนต์ (ไคลเอนต์เซิร์ฟเวอร์สามารถสื่อสารกับเซิร์ฟเวอร์โดยตรง) ฉันได้ทำงานกับสิ่งนี้: https://github.com/jvanveen/rnet/


0

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

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