Penjelasan terperinci tentang idea pelaksanaan komponen lata CascadeView (idea pemisahan dan senarai terpaut tunggal)_kemahiran javascript

Artikel ini memperkenalkan idea pelaksanaan fungsi lata yang serupa yang saya lakukan baru-baru ini untuk wilayah dan bandar Untuk mencapai pemisahan tanggungjawab dan prestasi dan tingkah laku sebanyak mungkin, fungsi ini dibahagikan kepada dua komponen dan. satu senarai terpaut telah digunakan Untuk melaksanakan logik lata utama, perenggan seterusnya mempunyai gif kesan demonstrasi. Walaupun ini adalah fungsi yang sangat biasa, logik pelaksanaan artikel ini adalah jelas dan kodnya mudah difahami Ia memisahkan diri daripada semantik lata wilayah dan perbandaran dan mempertimbangkan pemisahan prestasi dan tingkah laku ini artikel boleh membawa beberapa rujukan untuk nilai kerja anda, selamat membaca dan membetulkan.

Operasi lata lata

CascadeType PERSIST Cascade kegigihan (simpan) operasi

CascadeType MERGE cascade kemas kini (gabung) operasi

Jenis Cascade. REFRESH operasi muat semula lata, hanya operasi pemerolehan pertanyaan

Jenis Cascade. KELUARKAN operasi pemadaman lata

CascadeType SEMUA melata semua operasi di atas

Ambil sama ada untuk menangguhkan pemuatan Secara lalai, yang mempunyai satu bermakna memuatkan segera, yang mempunyai lebih banyak cara pemuatan tertunda

dipetakan oleh penyelenggaraan perhubungan

mappedBy= "parentid" menunjukkan bahawa atribut induk dalam kelas kanak-kanak digunakan untuk mengekalkan perhubungan Nama ini mestilah sama dengan nama atribut induk dalam kelas kanak-kanak.

Juga ambil perhatian bahawa jenis koleksi dalam kelas induk mestilah Senarai atau Set dan tidak boleh ditetapkan kepada ArrayList, jika tidak, ralat akan dilaporkan

Kesan tunjuk cara (muat turun kod, nota: kesan ini memerlukan http untuk dijalankan dan data dalam kesan adalah data simulasi, sebenarnya tidak dikembalikan oleh latar belakang, jadi data lungsur wilayah, bandar dan daerah yang anda lihat adalah yang sama):

Nota: Artikel ini menggunakan pelaksanaan teknikal blog berkaitan sebelum ini Jika perlu, anda boleh klik pada pautan di bawah untuk mengetahui lebih lanjut:

1) Penjelasan terperinci tentang pelaksanaan warisan Javascript: Sediakan class.js untuk mentakrifkan hubungan warisan antara kelas JavaScript dan kelas pembinaan

2) Helah jquery membenarkan mana-mana komponen untuk menyokong pengurusan acara seperti DOM: Sediakan eventBase.js untuk menyediakan fungsi pengurusan acara seperti DOM untuk sebarang contoh komponen;

3) Enkapsulasi sekunder komponen proksi caching ajax dan ajax jquery: AjaxCache: Menyediakan ajax.js dan ajaxCache.js, memudahkan panggilan ajax jquery dan melaksanakan proksi caching sisi klien untuk permintaan.

Mari kita ketahui lebih lanjut tentang keperluan fungsi ini dahulu.

1. Analisis fungsian

Gunakan komponen lata yang mengandungi tiga item lata untuk menggambarkan ciri ini:

1) Setiap item lata mungkin memerlukan pilihan yang digunakan sebagai gesaan input:

Dalam kes ini, pilihan kosong boleh dipilih dalam senarai data setiap item lata (yang mempunyai gesaan input):

Pilihan yang digunakan sebagai gesaan input mungkin juga tidak diperlukan: ​​

Dalam kes ini, hanya pilihan data boleh dipilih dalam senarai data setiap item lata dan pilihan kosong tidak boleh dipilih:

2) Jika halaman semasa disoal daripada pangkalan data dan medan yang sepadan dengan komponen lata mempunyai nilai, maka nilai pertanyaan akan digemakan kepada komponen lata:

Jika medan sepadan yang ditanya tidak mempunyai nilai, maka ia akan dipaparkan mengikut dua situasi yang diterangkan dalam perkara 1).

3) Setiap item lata membentuk satu hubungan senarai terpaut dalam struktur data Senarai data item lata seterusnya berkaitan dengan data yang dipilih oleh item lata sebelumnya.

4) Memandangkan isu prestasi, senarai data setiap item lata dimuatkan dan dipaparkan secara tidak segerak menggunakan ajax.

5) Selepas komponen lata dimulakan, muatkan senarai pertama item lata secara automatik.

6) Apabila item lata sebelumnya berubah, kosongkan senarai data semua item lata yang berkaitan secara langsung atau tidak Pada masa yang sama, jika nilai tukar item lata sebelumnya tidak kosong, ia akan dimuatkan secara automatik dan terus yang berkaitan dengannya. Apabila mengosongkan senarai data item lata, sila ambil perhatian: Jika item lata perlu memaparkan pilihan untuk gesaan input, pilihan mesti dikekalkan semasa mengosongkan.

7) Pertimbangkan sepenuhnya isu prestasi dan elakkan pemuatan berulang.

8) Memandangkan masalah penyerahan borang, apabila mana-mana item lata bagi komponen lata berubah, nilai yang dipilih oleh komponen lata mesti ditunjukkan dalam medan teks tersembunyi, supaya nilai komponen lata boleh dilalui medan teks diserahkan ke latar belakang.

Fungsinya lebih kurang sama seperti di atas.

2. Idea pelaksanaan

1) Struktur data

Komponen cascading berbeza daripada komponen lain kerana ia mempunyai beberapa kebergantungan pada data latar belakang Struktur data yang saya anggap lebih mudah untuk dilaksanakan ialah:

{
"id": 1,
"text": "北京市",
"code": 110000,
"parentId": 0
},
{
"id": 2,
"text": "河北省",
"code": 220000,
"parentId": 0
},
{
"id": 3,
"text": "河南省",
"code": 330000,
"parentId": 0
}

id ialah pengecam unik data Hubungan antara data dibina melalui parentId dan kod adalah medan perniagaan yang biasa. Jika kami mengikuti struktur data ini, antara muka kami untuk menanyakan senarai data item berlatarkan akan menjadi sangat mudah:

//查第一个级联项的列表
/api/cascade?parentId=0
//根据第一个级联项选的值，查第二个级联项的列表
/api/cascade?parentId=1
//根据第二个级联项选的值，查第三个级联项的列表
/api/cascade?parentId=4

Struktur ini juga mudah dikendalikan untuk bahagian belakang Walaupun secara struktur ia adalah struktur meja berbentuk pokok, semua pertanyaan adalah satu lapisan, jadi ia mudah untuk dilaksanakan.

Seperti yang dapat dilihat daripada demonstrasi pertanyaan sebelumnya, struktur ini dengan mudah boleh membantu kami menyatukan antara muka dan parameter pertanyaan data menjadi satu, yang sangat mudah untuk pembangunan komponen. Selepas kami mendapatkan struktur data ini daripada latar belakang, kami menghuraikan setiap bahagian data menjadi pilihan, seperti 1406d4fc0ffe83443ca693775fb1355bBandar Beijing4afa15d3069109ac30911f04c56f3338, jadi bahawa kedua-duanya Ia boleh melengkapkan paparan drop-down senarai data, dan juga boleh mengumpul nilai yang dipilih bagi item lata semasa melalui fungsi elemen borang pilih Akhirnya, apabila item lata berubah, pilihan yang dipilih juga boleh diperoleh dan disimpan di atasnya Nilai data-param-value digunakan sebagai parameter parentId untuk memuatkan senarai item berlatarkan seterusnya. Ini juga merupakan idea untuk melonjakkan pertanyaan dan analisis data komponen.

Tetapi apa yang perlu dipertimbangkan di sini ialah isu fleksibiliti Dalam projek sebenar, struktur data komponen lata mungkin ditakrifkan berdasarkan perhubungan yang serupa seperti id parentId, tetapi medannya tidak semestinya dipanggil kod teks id parentId. kemungkinan besar bidang lain. Maksudnya: apabila menghuraikan data ke dalam pilihan, tidak pasti medan mana yang digunakan untuk menghuraikan teks dan nilai pilihan, dan apakah nilai medan yang digunakan untuk atribut data-param-value; terdapat juga pertanyaan nama parameter parentId yang digunakan untuk data tidak boleh diperbaiki Kadangkala, jika kakitangan bahagian belakang telah menulis antara muka pertanyaan terlebih dahulu dan menggunakan nama lain, anda tidak boleh meminta mereka menukar nama parameter mereka kerana mereka memerlukannya -end; dan nilai 0 parentId=0 tidak boleh diperbaiki, kerana induk lapisan pertama data dalam projek sebenar mungkin kosong atau -1. Perkara-perkara ini mesti direka sebagai pilihan Dalam satu tangan, mereka memberikan nilai lalai, dan pada masa yang sama, mereka dibiarkan ke luar untuk menetapkan mengikut situasi sebenar, sebagai contoh, dalam pelaksanaan akhir artikel ini pilihan ditakrifkan seperti ini:

textField: 'text', //Nama medan yang akan dipaparkan dalam 5a07473c87748fb1bf73f23d45547ab8 elemen dalam data yang dikembalikan
valueField: 'text', //Nama medan yang akan ditetapkan pada nilai 5a07473c87748fb1bf73f23d45547ab8 dalam data yang dikembalikan
paramField: 'id', //Apabila memanggil antara muka pertanyaan data, nama medan yang sepadan dengan data yang akan dihantar ke latar belakang
paramName: 'parentId', //Apabila memanggil antara muka pertanyaan data, hantar nama parameter data selepas url
defaultParam: '', //Apabila menanyakan item lata pertama, nilai yang dihantar ke latar belakang biasanya 0, '', atau -1, dsb., menunjukkan bahawa data peringkat atas akan disoal

2) struktur html

Menurut item 1 analisis fungsi sebelumnya, terdapat dua jenis struktur HTML awal untuk komponen lata:

<ul id="licenseLocation-view" class="cascade-view clearfix">
<li>
<select class="form-control">
<option value="">请选择省份</option>
</select>
</li>
<li>
<select class="form-control">
<option value="">请选择城市</option>
</select>
</li>
<li>
<select class="form-control">
<option value="">请选择区县</option>
</select>
</li>
</ul>

atau

<ul id="companyLocation-view" class="cascade-view clearfix">
<li>
<select class="form-control">
</select>
</li>
<li>
<select class="form-control">
</select>
</li>
<li>
<select class="form-control">
</select>
</li>
</ul>

这两个结构唯一的区别就在于是否配置了用作输入提示的option。另外需要注意的是如果需要这个空的option，一定得把value属性设置成空，否则这个空的option在表单提交的时候会把option的提示信息提交到后台。

这两个结构最关键的是select元素，跟ul和li没有任何关系，ul跟li是为了UI而用到的；select元素没有任何语义，不用去标识哪个是省份，哪个是城市，哪个是区县。从功能上来说，一个select代表一个级联项，这些select在哪定义都不重要，我们只要告诉级联组件，它的级联项由哪些select元素构成就行了，唯一需要额外告诉组件的就是这些select元素的先后关系，但是这个通常都是用元素在html中的默认顺序来控制的。这个结构能够帮助我们把组件的功能尽可能地做到表现与行为分离。

3）职责分离和单链表的运用

从前面的部分也差不多能看出来了，这个级联组件如果按职责划分，可以分成两个核心的组件，一个负责整体功能和内部级联项的管理（CascadeView），另一个负责级联项的功能实现（CascadeItem）。另外为了更方便地实现级联的逻辑，我们只需要把所有的级联项通过链表连起来，通过发布-订阅模式，后一个级联项订阅前一个级联项发生改变的消息；当前面的级联项发生改变的时候，发布消息，通知后面的级联项去处理相关逻辑；通过链表的作用，这个消息可能可以一直传递到最后一个级联项为止。用图来描述的话，大致就是这个样子：

我们需要做的就是控制好消息的发布跟传递。

4）表单提交

为了能够方便地将级联组件的值提交到后台，可以把整个级联组件当成一个整体，对外提供一个onChanged事件，外部可通过这个事件获取所有级联项的值。由于存在多个级联项，所以在发布onChanged这个事件时，只能在任意级联项发生改变的时候，都去触发这个事件。

5）ajax缓存

在这个组件里面得考虑两个层级的ajax缓存，第一个是组件这一层级的，比如我把第一个级联项切换到了北京，这个时候第二个级联项就把北京的数据加载出来了，然后我把第一个级联项从北京切换到河北再切换到北京，这个时候第二个级联项要显示的还是北京的关联数据列表，如果我们在第一次加载这个列表的时候就把它的数据缓存下来了，那么这次就不用发起ajax请求了；第二个是ajax请求这一层级的，假如页面上有多个级联组件，我先把第一个级联组件的第一个级联项切换到北京，浏览器发起一个ajax请求加载数据，当我再把第二个级联组件的第一个级联项切换到北京的时候，浏览器还会再发一个请求去加载数据，如果我把第一个组件第一次ajax请求的返回的数据，先缓存起来，当第二个组件，用同样的参数请求同样的接口时，直接拿之前缓存觉得结果返回，这样也能减少一次ajax请求。第二个层级的ajax缓存依赖上文《对jquery的ajax进行二次封装以及ajax缓存代理组件：AjaxCache》，对于组件来说，它内部只实现了第一个层级的缓存，但是它不用考虑第二个层级的缓存，因为第二个层级的缓存实现对它来说是透明的，它不知道它用到的ajax组件有缓存的功能。

3. 实现细节

最终的实现包含了三个组件，CascadeView、CascadeItem、CascadePublicDefaults，前面两个是组件的核心，最后一个只是用来定义一些option，它的作用在CascadeItem的注释里面有详细的描述。另外在下面的代码中有非常详细的注释解释了一些关键代码的作用，结合着前面的需求来看代码，应该还是比较容易理解的。我以前倾向于用文字来解释一些实现细节，后来我慢慢觉得这种方式有点费力不讨好，第一是细节层面的语言不好组织，有的时候言不达意，明明想把一件事情解释清楚，结果反而弄得更加迷糊，至少我自己看自己写的东西就会这样的感触；第二是本身开发人员都具有阅读源码的能力，而且大部分积极的开发人员都愿意通过琢磨别人的代码来理解实现思路；所以我改用注释的方式来说明实现细节：）

CascadePublicDefaults:

define(function () {
return {
url: '',//数据查询接口
textField: 'text', //返回的数据中要在<option>元素内显示的字段名称
valueField: 'text', //返回的数据中要设置在<option>元素的value上的字段名称
paramField: 'id', //当调用数据查询接口时，要传递给后台的数据对应的字段名称
paramName: 'parentId', //当调用数据查询接口时，跟在url后面传递数据的参数名
defaultParam: '', //当查询第一个级联项时，传递给后台的值，一般是0，''，或者-1等，表示要查询第上层的数据
keepFirstOption: true, //是否保留第一个option（用作输入提示，如：请选择省份），如果为true，在重新加载级联项时，不会清除默认的第一个option
resolveAjax: function (res) {
return res;
}//因为级联项在加载数据的时候会发异步请求，这个回调用来解析异步请求返回的响应
}
});

CascadeView：

define(function (require, exports, module) {
var $ = require('jquery');
var Class = require('mod/class');
var EventBase = require('mod/eventBase');
var PublicDefaults = require('mod/cascadePublicDefaults');
var CascadeItem = require('mod/cascadeItem');
/**
* PublicDefaults的作用见CascadeItem组件内的注释
*/
var DEFAULTS = $.extend({}, PublicDefaults, {
$elements: undefined, //级联项jq对象的数组，元素在数据中的顺序代表级联的先后顺序
valueSeparator: ',', //获取所有级联项的值时使用的分隔符，如果是英文逗号，返回的值形如 北京市,区,朝阳区
values: '', //用valueSeparator分隔的字符串，表示初始时各个select的值
onChanged: $.noop //当任意级联项的值发生改变的时候会触发这个事件
});
var CascadeView = Class({
instanceMembers: {
init: function (options) {
//通过this.base调用父类EventBase的init方法
this.base();
var opts = this.options = this.getOptions(options),
items = this.items = [],
that = this,
$elements = opts.$elements,
values = opts.values.split(opts.valueSeparator);
this.on('changed.cascadeView', $.proxy(opts.onChanged, this));
$elements && $elements.each(function (i) {
var $el = $(this);
//实例化CascadeItem组件，并把每个实例的prevItem属性指向前一个实例
//第一个prevItem属性设置为undefined
var cascadeItem = new CascadeItem($el, $.extend(that.getItemOptions(), {
prevItem: i == 0 ? undefined : items[i - 1],
value: $.trim(values[i])
}));
items.push(cascadeItem);
//每个级联项实例发生改变都会触发CascadeView组件的changed事件
//外部可在这个回调内处理业务逻辑
//比如将所有级联项的值设置到一个隐藏域里面，用于表单提交
cascadeItem.on('changed.cascadeItem', function () {
that.trigger('changed.cascadeView', that.getValue());
});
});
//初始化完成自动加载第一个级联项
items.length && items[0].load();
},
getOptions: function (options) {
return $.extend({}, this.getDefaults(), options);
},
getDefaults: function () {
return DEFAULTS;
},
getItemOptions: function () {
var opts = {}, _options = this.options;
for (var i in PublicDefaults) {
if (PublicDefaults.hasOwnProperty(i) && i in _options) {
opts[i] = _options[i];
}
}
return opts;
},
//获取所有级联项的值，是一个用valueSeparator分隔的字符串
//为空的级联项的值不会返回
getValue: function () {
var value = [];
this.items.forEach(function (item) {
var val = $.trim(item.getValue());
val != '' && value.push(val);
});
return value.join(this.options.valueSeparator);
}
},
extend: EventBase
});
return CascadeView;
});

CascadeItem:

define(function (require, exports, module) {
var $ = require('jquery');
var Class = require('mod/class');
var EventBase = require('mod/eventBase');
var PublicDefaults = require('mod/cascadePublicDefaults');
var AjaxCache = require('mod/ajaxCache');
//这是一个可缓存的Ajax组件
var Ajax = new AjaxCache();
/**
* 有一部分option定义在PublicDefaults里面，因为CascadeItem组件不会被外部直接使用
* 外部用的是CascadeView组件，所以有一部分的option必须变成公共的，在CascadeView组件也定义一次
* 外部通过CascadeView组件传递所有的option
* CascadeView内部实例化CascadeItem的时候，再把PublicDefaults内的option传递给CascadeItem
*/
var DEFAULTS = $.extend({}, PublicDefaults, {
prevItem: undefined, // 指向前一个级联项
value: '' //初始时显示的value
});
var CascadeItem = Class({
instanceMembers: {
init: function ($el, options) {
//通过this.base调用父类EventBase的init方法
this.base($el);
this.$el = $el;
this.options = this.getOptions(options);
this.prevItem = this.options.prevItem; //前一个级联项
this.hasContent = false;//这个变量用来控制是否需要重新加载数据
this.cache = {};//用来缓存数据
var that = this;
//代理select元素的change事件
$el.on('change', function () {
that.trigger('changed.cascadeItem');
});
//当前一个级联项的值发生改变的时候，根据需要做清空和重新加载数据的处理
this.prevItem && this.prevItem.on('changed.cascadeItem', function () {
//只要前一个的值发生改变并且自身有内容的时候，就得清空内容
that.hasContent && that.clear();
//如果不是第一个级联项，同时前一个级联项没有选中有效的option时，就不处理
if (that.prevItem && $.trim(that.prevItem.getValue()) == '') return;
that.load();
});
var value = $.trim(this.options.value);
value !== '' && this.one('render.cascadeItem', function () {
//设置初始值
that.$el.val(value.split(','));
//通知后面的级联项做清空和重新加载数据的处理
that.trigger('changed.cascadeItem');
});
},
getOptions: function (options) {
return $.extend({}, this.getDefaults(), options);
},
getDefaults: function () {
return DEFAULTS;
},
clear: function () {
var $el = this.$el;
$el.val('');
if (this.options.keepFirstOption) {
//保留第一个option
$el.children().filter(':gt(0)').remove();
} else {
//清空全部
$el.html('');
}
//通知后面的级联项做清空和重新加载数据的处理
this.trigger('changed.cascadeItem');
this.hasContent = false;//表示内容为空
},
load: function () {
var opts = this.options,
paramValue,
that = this,
dataKey;
//dataKey是在cache缓存时用的键名
//由于第一个级联项的数据是顶层数据，所以在缓存的时候用的是固定且唯一的键：root
//其它级联项的数据缓存时用的键名跟前一个选择的option有关
if (!this.prevItem) {
paramValue = opts.defaultParam;
dataKey = 'root';
} else {
paramValue = this.prevItem.getParamValue();
dataKey = paramValue;
}
//先看数据缓存中有没有加载过的数据，有就直接显示出来，避免Ajax
if (dataKey in this.cache) {
this.render(this.cache[dataKey]);
} else {
var params = {};
params[opts.paramName] = paramValue;
Ajax.get(opts.url, params).done(function (res) {
//resolveAjax这个回调用来在外部解析ajax返回的数据
//它需要返回一个data数组
var data = opts.resolveAjax(res);
if (data) {
that.cache[dataKey] = data;
that.render(data);
}
});
}
},
render: function (data) {
var html = [],
opts = this.options;
data.forEach(function (item) {
html.push(['<option value="',
item[opts.valueField],
'" data-param-value="',//将paramField对应的值存放在option的data-param-value属性上
item[opts.paramField],
'">',
item[opts.textField],
'</option>'].join(''));
});
//采用append的方式动态添加，避免影响第一个option
//最后还要把value设置为空
this.$el.append(html.join('')).val('');
this.hasContent = true;//表示有内容
this.trigger('render.cascadeItem');
},
getValue: function () {
return this.$el.val();
},
getParamValue: function () {
return this.$el.find('option:selected').data('paramValue');
}
},
extend: EventBase
});
return CascadeItem;
});

4. demo说明

演示代码的结构：

其中框起来的就是演示的相关部分。html/regist.html是演示效果的页面，js/app/regist.js是演示效果的入口js：

define(function (require, exports, module) {
  var $ = require('jquery');
  var CascadeView = require('mod/cascadeView');
  function publicSetCascadeView(fieldName, opts) {
    this.cascadeView = new CascadeView({
      $elements: $('#' + fieldName + '-view').find('select'),
      url: '../api/cascade.json',
      onChanged: this.onChanged,
      values: opts.values,
      keepFirstOption: this.keepFirstOption,
      resolveAjax: function (res) {
        if (res.code == 200) {
          return res.data;
        }
      }
    });
  }
  var LOCATION_VIEWS = {
    licenseLocation: {
      $input: $('input[name="licenseLocation"]'),
      keepFirstOption: true,
      setCascadeView: publicSetCascadeView,
      onChanged: function(e, value){
        LOCATION_VIEWS.licenseLocation.$input.val(value);
      }
    },
    companyLocation: {
      $input: $('input[name="companyLocation"]'),
      keepFirstOption: false,
      setCascadeView: publicSetCascadeView,
      onChanged: function(e, value){
        LOCATION_VIEWS.companyLocation.$input.val(value);
      }
    }
  };
  LOCATION_VIEWS.licenseLocation.setCascadeView('licenseLocation', {
    values: LOCATION_VIEWS.licenseLocation.$input.val()
  });
  LOCATION_VIEWS.companyLocation.setCascadeView('companyLocation', {
    values: LOCATION_VIEWS.companyLocation.$input.val()
  });
});

注意以上代码中LOCATION_VIEWS这个变量的作用，因为页面上有多个级联组件，这个变量其实是通过策略模式，把各个组件的相关的东西都用一种类似的方式管理起来而已。如果不这么做的话，很容易产生重复代码；这种形式也比较有利于在入口文件这种处理业务逻辑的地方，进行一些业务逻辑的分离与封装。

5. others

这估计是在现在公司写的最后一篇博客，过两天就得去新单位去上班了，不确定还能否有这么多空余的时间来记录平常的工作思路，但是好歹已经培养了写博客的习惯，将来没时间也会挤出时间来的。今年的目标主要是拓宽知识面，提高代码质量，后续的博客更多还是在组件化开发这个类别上，希望以后能够得到大家的继续关注脚本之家网站！