1. 为什么我们需要一个自定义的日期时间选择器？

做微信小程序开发的朋友，估计都遇到过这个头疼的问题：需要一个让用户同时选择日期和时间的组件。你兴冲冲地打开官方文档，找到 picker 组件，结果发现，要么只能选日期（mode="date"），要么只能选时间（mode="time"）。想在一个弹窗里搞定年月日时分？不好意思，官方没提供。

我最早遇到这个需求是在做一个预约类的小程序上。用户需要选择具体的服务时间，精确到分钟。当时我的第一反应也是用官方 picker 组合，但试下来体验非常割裂。先弹一个日期选择器，选完确定，再弹一个时间选择器。用户操作被打断两次，流程繁琐，而且两个弹窗样式还不统一，看着就很别扭。后来看到企业微信里那个集成的日期时间选择器，体验就流畅多了，一个弹窗里全搞定。于是我就琢磨，能不能自己动手，在小程序里也实现一个类似的效果？

这就是我们今天要聊的核心：利用微信小程序官方的 mp-half-screen-dialog（半屏弹窗）和 picker-view（滚动选择器视图）组件，封装一个高度自定义、体验流畅的日期时间选择器组件。 这个组件不仅能满足同时选择年月日时分的基本需求，还能通过配置起始和结束时间，灵活控制可选范围，最后返回一个毫秒级的时间戳，方便后续业务逻辑处理。对于需要复杂时间选择场景的开发者，比如做课程预约、会议安排、订单时间筛选等，这个方案会非常实用。

2. 核心组件拆解与选型思路

在动手之前，我们先搞清楚要用到的两个“武器”是什么，以及为什么选它们。

2.1 mp-half-screen-dialog：优雅的容器

mp-half-screen-dialog 是微信小程序官方提供的一个扩展组件，需要单独引入。它最大的特点就是从屏幕底部向上滑出，占据大约一半的屏幕高度。这种交互方式现在非常流行，比如微信自己的各种选择器、分享面板都是这个套路。

为什么不用普通的 modal 弹窗呢？我试过，体验差很多。普通弹窗会遮挡整个屏幕，给人一种中断感，而半屏弹窗更像是从当前页面“拉”出一个扩展面板，上下文连贯性更好，用户心理负担也小。对于日期时间选择这种需要频繁滑动操作、信息量又比较大的场景，半屏弹窗提供了更充裕、更专注的操作空间。

不过，原生的 mp-half-screen-dialog 样式可能和你的小程序设计风格不搭。别担心，它提供了 ext-class 这个属性，允许我们从外部传入自定义的类名，从而实现精准的样式定制，而不会污染全局样式。这是我们实现个性化外观的关键。

2.2 picker-view：灵活的“滚轮”

picker-view 是另一个核心。你可以把它理解为一组可以自由组合的“滚轮”。picker 组件是封装好的，模式固定；而 picker-view 更底层、更灵活，它内部通过 picker-view-column 来定义每一列的内容，我们可以完全控制每一列展示什么数据。

对于日期时间选择器，我们至少需要三列“滚轮”：一列展示日期（比如“5月20日 周一”），一列展示小时（00-23），一列展示分钟（00-59）。picker-view 完美契合这个需求。我们可以通过绑定数据数组，动态生成每一列的内容，并通过 bindchange 事件来捕获用户的选择。

把这两者结合起来，思路就很清晰了：用 mp-half-screen-dialog 作为承载交互的“房子”，用 picker-view 在房子里打造日期、小时、分钟三组“滚轮”。 用户打开弹窗，滑动选择，点击确定，我们就把三组“滚轮”的当前值组合成一个完整的时间戳，通过事件抛出去。整个交互一气呵成。

3. 一步步构建组件：从零到一的实战

光说不练假把式，我们直接上代码，看看这个组件是怎么从无到有搭建起来的。我会把关键逻辑掰开揉碎了讲，哪怕你之前没封装过小程序组件，跟着做也能搞定。

3.1 组件结构搭建 (WXML)

首先看视觉层，也就是 WXML 文件。这里定义了组件的骨架。

<!-- components/date-time-picker/date-time-picker.wxml -->
<mp-half-screen-dialog
  show="{{ show }}"
  maskClosable="{{ false }}"
  closabled="{{ false }}"
  ext-class="date-time-dialog"
  catchtouchmove="preventTouchMove"
  bindclose="bindclose"
>
  <view slot="desc" class="date-time-container">
    <view class="date-time-body">
      <!-- 日期选择列 -->
      <view class="selector-panel selector-panel-date">
        <picker-view
          indicator-style="height: 55px;"
          mode="selector"
          value="{{ [dateIndex] }}"
          class="selector-picker"
          bindchange="dateChange"
          bindpickstart="bindpickstart"
          bindpickend="bindpickend"
        >
          <picker-view-column>
            <view wx:for="{{ dateArr }}" wx:key="index" class="selector-item selector-item-date">{{ item.name }}</view>
          </picker-view-column>
        </picker-view>
      </view>

      <!-- 小时选择列 -->
      <view class="selector-panel">
        <picker-view ... bindchange="hourChange">
          <picker-view-column>
            <view wx:for="{{ hourArr }}" wx:key="index" class="selector-item">{{ item }}</view>
          </picker-view-column>
        </picker-view>
      </view>

      <!-- 分钟选择列 -->
      <view class="selector-panel">
        <picker-view ... bindchange="minChange">
          <picker-view-column>
            <view wx:for="{{ minArr }}" wx:key="index" class="selector-item">{{ item }}</view>
          </picker-view-column>
        </picker-view>
      </view>
    </view>

    <view class="date-time-oper">
      <button type="default" class="weui-btn oper-btn" bindtap="bindclose">取消</button>
      <button type="primary" class="weui-btn oper-btn" bindtap="handleSubmit" disabled="{{ disabled }}">确定</button>
    </view>
  </view>
</mp-half-screen-dialog>

这里有几个细节值得注意：

1. ext-class="date-time-dialog"：这是我们自定义样式的入口。所有针对这个半屏弹窗的特殊样式，都会写在这个类名下，确保不会影响小程序里其他地方用到的 mp-half-screen-dialog。
2. catchtouchmove="preventTouchMove"：这个很重要。半屏弹窗在滑动时，如果手指在内容区域，可能会连带触发背后页面的滚动。这个方法就是为了阻止这个行为，让交互更稳定。
3. 三个独立的 picker-view：分别对应日期、小时、分钟。注意日期列的容器多了一个 selector-panel-date 的类，这是为了在样式上让它宽度自适应，占据更多空间，因为日期字符串通常比较长。
4. 按钮状态管理：确定按钮绑定了 disabled="{{ disabled }}"。这个状态会在用户开始滚动选择器（bindpickstart）时置为 true，结束滚动（bindpickend）时恢复。这是一个提升体验的细节，防止用户在滚动动画还没停稳时就点击确定，导致选中的值不是最终看到的那个。

3.2 组件逻辑核心 (JS)

逻辑层是组件的大脑，负责数据处理和交互响应。代码有点长，我们分块来理解。

第一步：定义组件属性与数据

// components/date-time-picker/date-time-picker.js
const utils = require('../utils/util') // 假设有一个日期格式化工具
const yearTimestamp = 365 * 24 * 60 * 60 * 1000

Component({
  properties: {
    // 控制弹窗显示/隐藏
    show: {
      type: Boolean,
      value: false,
      observer: '_showChange' // 监听变化，显示时初始化数据
    },
    // 可选时间范围的开始时间戳（毫秒）
    startTime: {
      type: Number,
      value: +new Date() - yearTimestamp // 默认一年前
    },
    // 可选时间范围的结束时间戳（毫秒）
    endTime: {
      type: Number,
      value: +new Date() + yearTimestamp // 默认一年后
    }
  },
  data: {
    disabled: false,
    dateIndex: null, // 日期列当前选中索引
    hourValue: '',   // 小时列当前选中值
    minValue: '',    // 分钟列当前选中值
    dateArr: [],     // 日期列数据数组
    hourArr: [],     // 小时列数据数组 (00-23)
    minArr: [],      // 分钟列数据数组 (00-59)
    activeTime: null // 最终组合出的时间戳
  },

properties 定义了组件对外接收的参数。show 控制显隐；startTime 和 endTime 给了我们巨大的灵活性，你可以让用户选择未来一周的时间，也可以选择过去三个月的时间，完全由业务决定。observer 监听 show 的变化，一旦变为 true（弹窗打开），就触发 _showChange 方法去准备数据。

第二步：动态生成选择器数据 这是最核心的算法部分，主要逻辑在 getDateTimeData 和 getDateData 方法里。

methods: {
  _showChange(e) {
    if (e) { // 当show变为true时
      this.getDateTimeData(); // 生成日期、小时、分钟数据
      this.initData(); // 初始化默认选中值（比如设为当前时间）
    }
  },

  getDateTimeData() {
    const mins = [];
    const hours = [];
    // 生成固定的分钟和小时数组
    for (let i = 0; i < 60; i++) {
      mins.push(i.toString().padStart(2, '0')); // 补零，变成'00','01'...
    }
    for (let j = 0; j < 24; j++) {
      hours.push(j.toString().padStart(2, '0'));
    }

    // 日期数组需要根据startTime和endTime动态计算
    const dates = this.getDateData();

    this.setData({
      hourArr: hours,
      minArr: mins,
      dateArr: dates
    });
  },

  getDateData() {
    const start = new Date(this.data.startTime);
    const end = new Date(this.data.endTime);
    const now = new Date();
    const dateArr = [];

    // 这是一个遍历从开始日期到结束日期的循环
    // 为了清晰，这里简述逻辑，实际代码需要处理年、月、日的边界
    let current = new Date(start);
    while (current <= end) {
      const timeStamp = +current;
      let nameStr;
      // 如果是今年，不显示年份，否则显示年份
      if (current.getFullYear() === now.getFullYear()) {
        nameStr = utils.formatTime(timeStamp, '{m}月{d}日 周{a}');
      } else {
        nameStr = utils.formatTime(timeStamp, '{y}年{m}月{d}日 周{a}');
      }
      // 如果是今天，特殊标记
      if (current.toDateString() === now.toDateString()) {
        nameStr = '今天';
      }

      dateArr.push({
        name: nameStr,
        value: timeStamp // 存储该日期0点的时间戳
      });

      // 日期加一天
      current.setDate(current.getDate() + 1);
    }
    return dateArr;
  },

getDateData 方法是精华。它根据传入的 startTime 和 endTime，生成这个时间段内每一天的数组。每个数组元素是一个对象，包含展示的文本 name（如“5月20日 周一”）和该日期0点的时间戳 value。这里用了一个小技巧：存储日期0点的时间戳。这样，在结合用户选择的小时和分钟时，只需要在这个基础时间戳上加上对应的小时和分钟的毫秒数即可，计算起来非常方便和准确。

第三步：处理用户交互与数据组合 用户滑动任何一个选择器，都会触发对应的 change 事件。

  dateChange(e) {
    const selectedIndex = e.detail.value[0];
    const selectedDate = this.data.dateArr[selectedIndex];
    // 核心计算：日期0点时间戳 + 小时部分 + 分钟部分
    const hourMs = Number(this.data.hourValue) * 60 * 60 * 1000;
    const minMs = Number(this.data.minValue) * 60 * 1000;
    const finalTime = selectedDate.value + hourMs + minMs;

    this.setData({
      dateIndex: selectedIndex,
      activeTime: finalTime
    });
  },

  hourChange(e) {
    const selectedHour = this.data.hourArr[e.detail.value[0]];
    // 同理，基于当前选中的日期和分钟，重新计算总时间戳
    const date = this.data.dateArr[this.data.dateIndex].value;
    const minMs = Number(this.data.minValue) * 60 * 1000;
    const finalTime = date + (Number(selectedHour) * 60 * 60 * 1000) + minMs;

    this.setData({
      hourValue: selectedHour,
      activeTime: finalTime
    });
  },
  // minChange 逻辑类似...

  handleSubmit() {
    if (!this.data.disabled && this.data.activeTime) {
      this.bindclose(); // 关闭弹窗
      // 抛出change事件，携带毫秒级时间戳
      this.triggerEvent('change', { value: this.data.activeTime });
    }
  },

  bindpickstart() { this.setData({ disabled: true }); },
  bindpickend() { this.setData({ disabled: false }); },

每次滑动，我们都实时地将日期、小时、分钟三部分组合成一个完整的毫秒级时间戳，并存入 activeTime。当用户点击“确定”时，直接把这个 activeTime 通过 triggerEvent 抛给父组件。父组件只需要监听 bindchange 事件，就能拿到用户选择的精确时间，非常干净。

3.3 样式隔离与美化 (WXSS)

样式是用户体验的最后一道关。我们通过 ext-class 实现了样式隔离，所有自定义样式都写在 date-time-dialog 这个类名下。

/* 在 app.wxss 或页面/组件的 wxss 中 */
.date-time-dialog .date-time-container {
  min-height: 350px !important; /* 确保弹窗有足够高度 */
  display: flex;
  flex-direction: column;
}

.date-time-dialog .date-time-body {
  width: 100% !important;
  display: flex;
  flex: auto; /* 占据主要空间 */
}

.date-time-dialog .selector-panel {
  width: 80px; /* 小时和分钟列固定宽度 */
  display: flex;
  align-items: center;
}

.date-time-dialog .selector-panel-date {
  flex: auto; /* 日期列宽度自适应，占据剩余空间 */
}

.date-time-dialog .selector-picker {
  width: 100%;
  height: 80%;
  font-size: 24px; /* 调整滚轮字体大小 */
}

.date-time-dialog .selector-item {
  line-height: 50px !important;
  text-align: center;
  font-size: 18px;
}

.date-time-dialog .selector-item-date {
  font-size: 16px; /* 日期文字稍小，因为内容长 */
}

.date-time-dialog .date-time-oper {
  flex: none; /* 按钮栏不伸缩 */
  display: flex;
  justify-content: space-between;
  padding: 15px;
}

关键点在于使用 .date-time-dialog 作为前缀，这样样式规则就只会作用于我们这个特定的半屏弹窗内部。通过 Flex 布局，我们让日期列可以自适应宽度，而小时和分钟列保持固定宽度，看起来更协调。indicator-style 属性用于设置中间选中条的样式，这里设置了高度，让选中状态更明显。

4. 在页面中使用你的自定义组件

组件封装好了，用起来就非常简单了，和用官方组件没什么两样。

第一步：在页面的 JSON 文件中声明引用

{
  "usingComponents": {
    "date-time-picker": "/components/date-time-picker/date-time-picker"
  }
}

第二步：在页面的 WXML 中放置组件并绑定事件

<view>
  <button bindtap="openPicker">选择日期时间</button>
  <text>您选择的时间戳是：{{ selectedTimeStamp }}</text>
  <text>格式化后是：{{ formattedTime }}</text>

  <date-time-picker
    id="myPicker"
    show="{{ showPicker }}"
    start-time="{{ startTimestamp }}"
    end-time="{{ endTimestamp }}"
    bind:change="onDateTimeChange"
  />
</view>

第三步：在页面的 JS 中处理逻辑

Page({
  data: {
    showPicker: false,
    selectedTimeStamp: null,
    formattedTime: '',
    // 例如，允许选择从今天起未来7天的时间
    startTimestamp: new Date().getTime(),
    endTimestamp: new Date().getTime() + 7 * 24 * 60 * 60 * 1000
  },

  openPicker() {
    this.setData({ showPicker: true });
  },

  onDateTimeChange(e) {
    const ms = e.detail.value; // 这里拿到毫秒级时间戳
    console.log('用户选择的时间戳：', ms);

    // 你可以用任何喜欢的方式格式化这个时间戳
    const date = new Date(ms);
    const formatted = `${date.getFullYear()}-${date.getMonth()+1}-${date.getDate()} ${date.getHours()}:${date.getMinutes().toString().padStart(2, '0')}`;

    this.setData({
      selectedTimeStamp: ms,
      formattedTime: formatted,
      showPicker: false // 组件内部会关，这里再关一次确保状态同步
    });

    // 接下来，你可以用这个时间戳去调接口、筛选数据等等
  }
})

5. 避坑指南与高级技巧

在实际项目中踩过几次坑后，我总结了一些经验和可以优化的点，能让这个组件更健壮、更好用。

坑点一：性能与超大时间范围 如果你的 startTime 和 endTime 跨度非常大（比如好几年），getDateData 方法生成的 dateArr 数组会非常庞大，可能导致初始化卡顿。解决方案有两个：

1. 业务层面限制：合理设计需求，不要让用户在一个选择器里滑动选择跨度太大的日期，这本身体验也不好。可以拆分成先选年月，再选日时分。
2. 技术层面优化：实现一个“虚拟滚动”的逻辑。不要一次性生成所有日期的 DOM 节点，只渲染当前可视区域及前后缓冲区的几十条数据。随着滚动动态计算和更新数据。这对小程序开发有一定挑战，但对于超长列表是终极解决方案。

坑点二：时区问题 new Date() 和 getTime() 获取的是本地时间的时间戳。如果你的用户跨时区，或者服务端要求 UTC 时间，就需要小心处理。一个稳妥的做法是，组件始终处理为本地时间，在将时间戳传给服务端时，明确说明这是“本地时间的毫秒数”，由服务端根据自身需要转换。或者，你可以在组件内部增加一个 utc 的属性，如果为 true，则所有计算基于 Date.UTC() 方法。

高级技巧一：支持“此刻”或“清空” 有时用户想快速选择当前时间，或者清空已选时间。可以在按钮栏增加一个“此刻”按钮，点击后自动将三个 picker-view 的选中值设置为当前时间。清空功能则需要定义一种特殊状态（比如 activeTime 为 null），并在抛给父组件的事件中区分。

高级技巧二：更灵活的时间粒度 现在的组件固定是“日期-小时-分钟”。你可以通过扩展 properties，比如增加一个 granularity 属性，允许传入 'date'（只选日期）、'datetime'（日期+时间）、'time'（只选时间）等，从而动态渲染不同的 picker-view-column，实现一个组件多种用途。

样式定制深一度： picker-view 的选中指示器（中间那根横线）样式可以通过 indicator-style 调整，但它的上下蒙层（渐变遮罩）颜色是系统默认的。如果你想要完全一致的视觉风格，可能会觉得别扭。遗憾的是，小程序目前没有开放这两个蒙层的样式修改。一个变通的方法是，自己用 view 模拟滚轮选择器，但这会牺牲原生滚动的流畅性。所以，在大多数情况下，接受系统样式，或者通过整体设计风格来弱化它的存在，是更实际的选择。

封装这个组件的过程，让我对小程序组件的通信、样式隔离和交互细节有了更深的理解。最大的收获不是代码本身，而是这种“发现问题-寻找官方能力-组合创新-封装复用”的思路。当你再遇到官方组件无法满足的定制化需求时，不妨也试试拆解它，看看能不能用更底层的组件组合出来。