小程序开发中，数据的监听和响应是非常重要的。为了更方便地监听数据的变化，小程序提供了 observe 方法。本文将详细介绍如何在小程序中使用 observe 实现数据监听，以及一些常见的应用场景。

什么是 observe？

observe 是小程序中的一个方法，用于监听数据的变化并触发相应的回调函数。它可以用于监听页面数据、组件数据以及其他数据对象。

如何使用 observe？

监听页面数据

在页面的 .js 文件中，可以使用 Page 函数中的 data 中的 observe 字段来监听数据的变化。以下是一个示例：

// pages/index/index.js

Page({

  data: {

    count: 0,

  },



  // 监听 count 数据的变化

  observe: {

    'count': function (newVal, oldVal) {

      console.log('count 的值从 ' + oldVal + ' 变为 ' + newVal);

    }

  },



  // 增加 count 值的函数

  increaseCount() {

    this.setData({

      count: this.data.count + 1,

    });

  },

});

在上述示例中，我们在 observe 字段中定义了一个监听器，当 count 数据发生变化时，会触发相应的回调函数。

监听组件数据

在小程序的组件中，也可以使用 observe 来监听组件数据的变化。以下是一个示例：

// components/my-component/my-component.js

Component({

  data: {

    message: 'Hello, World!',

  },



  methods: {

    changeMessage() {

      this.setData({

        message: 'New Message!',

      });

    },

  },



  // 监听 message 数据的变化

  observe: {

    'message': function (newVal, oldVal) {

      console.log('message 的值从 ' + oldVal + ' 变为 ' + newVal);

    }

  },

});

在组件的 observe 字段中同样定义了一个监听器，用于监听 message 数据的变化。

常见应用场景

1. 数据绑定

observe 可以用于在数据变化时自动更新视图，实现数据绑定。这对于构建响应式的页面和组件非常有用。

2. 数据校验

通过监听数据的变化，可以在数据变化时进行校验，确保数据的合法性。例如，监听输入框中的文本变化并验证其格式。

3. 事件通知

当某个数据变化时，可以通过 observe 触发相关的事件，通知其他部分的代码执行相应的操作。

4. 数据持久化

在某些情况下，需要将数据持久化到本地存储或服务器，可以在数据变化时触发数据保存操作。

注意事项和最佳实践

在使用 observe 进行数据监听时，有一些注意事项和最佳实践需要考虑：

1. 
   

   数据引用类型的监听：当监听对象是引用类型（例如对象或数组）时，需要注意对象的引用是否发生变化。observe 监听的是对象的引用，而不是对象内部属性的变化。如果需要监听对象内部属性的变化，可以使用深度监听或手动触发。

   
   


2. 
   

   避免过多监听器：不要过度使用 observe，因为过多的监听器可能会导致性能问题。只监听那些真正需要监控的数据。

   
   


3. 
   

   监听器的性能开销：监听器的回调函数在数据变化时会被频繁调用，因此要确保回调函数的执行效率较高，以避免影响应用的性能。

   
   


4. 
   

   避免循环引用：在监听器回调函数中不要再次修改被监听的数据，以防止循环引用和无限循环触发监听器。

   
   


5. 
   

   生命周期管理：在页面或组件销毁时，要记得取消监听以防止内存泄漏。可以在 onUnload 生命周期中取消监听。

   
   

onUnload() {

  this.setData({

    observe: null, // 取消监听

  });

}

通过谨慎使用 observe，你可以实现有效的数据监听和响应，提高小程序应用的可维护性和性能。

结语

observe 是小程序中非常有用的功能，它允许你监听数据的变化并执行相应的操作。无论是在页面中还是在组件中，都可以使用 observe 来实现数据的监听和响应。通过合理利用 observe，你可以构建更加动态和交互性的小程序应用。

这个故事有点长 - 苏州

👉故事的开始

之前已经去过苏州了，只是当时觉得园林都一样，就只去了拙耕园、留园、山塘街、观前街、平江路、平门古城墙、金鸡湖，印象最深刻的就是，当初围绕着金鸡湖走了一半，累了打车回去了。

最近心情有点郁闷😠，决定去走走，思来想去，就发现苏州还有地方没去，于是乎就去了，提前一天定了酒店，住的花居酒店，挺不错的，停车位很多，免费停车，其他酒店都是40一天，由于姑苏区车辆限行，就在姑苏通上申请了，结果都回来了，申请才通过。

🚗第一天

由于没有那么远的距离，九点才从上海出发，大概十一点左右到的酒店，然后再楼下简单吃了顿饭，就驱车去了虎丘，在停车场还有人指导我倒车入库，然后就一直推荐旅游套餐，说虎丘+XXX好几个地方只需100元，车接车送，很划算，不能单买虎丘的，于是乎果断在美团上买了70的门票。

大概逛了三四个小时，期间卖了一块网红雪糕，宝塔形状的。五点左右就回去了，休息了一个小时，然后就打车去金鸡湖看音乐喷泉，是个妹子开的车，然后在车上聊了起来，期间还为我表演了一次丝滑插车，下车时还让我给她了一个好评。七点半开始，我六点半左右就到了，结果还是没有抢到最佳观看位置，都太卷了，人很多，与外滩有一拼。

在等待期间，认真观察了苏州的“大裤衩”，期间总共变了三种颜色，期初是文字，后来变成了图案。

从金鸡湖回来， 坐地铁一号线去了观前街，第二次来了，故地重游，感觉就是不一样，又拍了两张照片😄，还是那么的热闹 。

🌅第二天

一觉睡到了十点，吃了早饭去狮子林，搜了一下，距离只有一公里多一些，果断又打车了，门票40元，中间蹭了导游的一些讲解，又看到了九狮台，能看的出来是九头狮子吗？

接下来就是假山群，里面有很多山洞，据说女儿国就在这里拍的，当初乾隆皇帝就在这里完了很久，直呼真有趣，于是就有了真趣亭。

之后在附近吃了松鼠桂鱼，然后就回去了，一路都在与天气赛跑，一段下雨一段晴。

🚩起点既是终点

时间过得好快，兜兜转转了一圈，从哪来又回了哪去，晚安🌜🌛。

这个故事有点长 - 故事还在继续🏃🏃🏃.......

作者：蒋静

前言

回滚是每个开发者必须熟悉的操作，它的重要性不言而喻，必要的时候我们可以通过回滚减少错误的代码对用户影响的时间。回滚的方式有很多种，方式有好也有坏，比如说使用 git 仓库回滚有可能会覆盖其他业务的代码，不稳定，构建产物的回滚最安全，便于优先解决线上问题。

构建部署之“痛”

我的几段公司的工作经历：

1. 第一段经历，是在一个传统的公司，没有运维，要我们自己登录一个跳板机，把文件部署到服务器，非常麻烦。


2. 第二段经历，是在一个初创公司，基建几乎没有，前端的规模也很小，发布就是打个 zip 包发给运维，运维去上线。但是久而久之，运维也就不耐烦了。


3. 后来去了稍微大些的公司，构建、部署有一套比较完善的体系，在网页上点击按钮就可以了。

那么构建部署是如何实现的呢？下面我要来介绍古茗的部署和回滚代码机制。

发布分析

我们的最终目的是发布上线，我们发布的是什么呢？是一条分支，所以我们需要先创建一条分支（更加规范的步骤应该是：基于某个需求和某个应用去拉一条分支）。在分支上开发完我们就可以进行发布的操作啦！

这个时候我们就可以操作发布，我们填写需要的配置项后就可以点击发布按钮了。但是肯定不能让所有人随随便便就发布成功，所以我们要进行一些前置校验。比如说你有没有发布的权限、代码有没有冲突、是不是节假日或非发布窗口期、这个应用有没有正在被发布。。。等等的校验，总之就是确保代码是可以被你发布的。

然后我们的发布平台就会叫 Jenkins 拿着仓库信息、分支信息，以及其他等等的配置信息去仓库拉取代码了，拉到代码之后根据不同类型的应用进行区分，进行编译打包（这个过程不同应用之间是不同的），生成对应的产物。

1. 容器化发布

注：图中Wukong是我们自研DevOps平台

容器化发布发布的是镜像，镜像 id 代表了这次发布和这个镜像的关联关系。回滚的时候只需要找到这次发布对应的 id ，运维脚本根据这个 docker 的 id 找到 docker 镜像，直接部署这次 docker 镜像，做到回滚。由于发布的是 docker 的镜像，不仅可以保证产物是相同的，发布还很快。

容器化之前的发布：先找到对应的发布，根据这次发布找到对应的 tag，然后打包发布，但是这样只能保证业务代码是相同的，不能保证机器环境、打包机的环境、依赖的版本、打包的产物等等是一样的，并且需要的时间比容器化的方式慢得多。

2. oss发布

oss 发布和容器化发布流程的区别在于不用打包镜像而是将js、css等资源传到了 oss。通过 oss 发布的应用，只需要记住版本和 oss 上面资源路径的对应关系就可以了。

例如在我们这里的实现是：每次发布完成之后会记下有 hash 的 manifest 的地址，点击回滚后会根据发布 id 找到当次的产物，通过 oss 将 manifest 内容替换为有hash 的，从而就切换了访问的资源（html 的 manifest 地址不变，改变的是 manifest 文件的内容）。

3. 小程序

钉钉小程序的回滚就比较简单了，一般在我们点击回滚之后，内部会通过 http 接口调用小程序的 api 传递需要回滚的版本好后即回滚完成。或者你也可以选择手动到开发者后台的历史版本点回滚。
例如： open.dingtalk.com/document/or…

未来展望

有了完善的部署回滚机制，我们的产研团队才能有更好的交付体验。工作中的业务价值在我们整个交付内容占比应当是比较高的，而不应当把大量的时间花费在处理部署等流程上，让我们能够更快的去完成业务交付。

更好更稳定的回滚方式，能够让我们做到出现问题时快速恢复。这样才能保证一个较低的试错成本。

对于古茗来说，我认为一个很大的优势是，我们的规模不算很大，可以更好地做好研发流程对应的工具服务的统一，打通研发流程的各个流程，每个环节之间更好地进行串联，更好的助力业务发展。

前言

前2篇文章，分别介绍了dat.gui和纹理贴图，老是理论没有实战也是没有什么意思的，今天我们就来着手一个小案例，赶紧实现起来，让你的博客更加炫酷！

这个案例包含了tweenjs动画库的使用，该动画库已在three.js中内置，路径为： examples/jsm/libs/tween.module.js,使用起来也是比较简单。

初始化

老样子，场景、相机、渲染器三要素初始化，并导入需要的插件库，插件库都已在three中内置：

import * as THREE from 'three';

// tween动画库

import TWEEN from 'three/addons/libs/tween.module.js';

//通过轨迹球控件TrackballControls 我们可以实现场景的旋转、缩放、平移等功能

import { TrackballControls } from 'three/addons/controls/TrackballControls.js'

// 雪碧图

import { CSS3DRenderer, CSS3DSprite } from 'three/addons/renderers/CSS3DRenderer.js'



// 定义场景、相机、渲染器

let scene, camera, renderer;



// 初始化

init()

// 渲染

animate();



function init() {

    // 透视相机  远端距离最好设大一点  不然会展示不全

    camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 10000);

    // 相机位置

    camera.position.set(600, 400, 1500);

    // 相机朝向位置

    camera.lookAt(0, 0, 0);



    // 场景

    scene = new THREE.Scene();



    // 渲染画布

    renderer = new CSS3DRenderer();

    renderer.setSize(innerWidth, window.innerHeight);

    document.getElementById('container').appendChild(renderer.domElement);

}



// 渲染

function animate() {

    requestAnimationFrame(animate);

    renderer.render(scene, camera)

}

CSS3DSprite创建521个水球

// 定义小球数量

const particlesTotal = 512;

// 定义位置

const positions = [];

// 定义物体

const objects = []

const image = document.createElement('img');

image.addEventListener('load', () => {

    for (let i = 0; i < particlesTotal; i++) {

        //   cloneNode() 方法可创建指定的节点的精确拷贝

        const object = new CSS3DSprite(image.cloneNode())

        // 随机分布位置 -2000 2000的立方体内

        object.position.x = Math.random() * 4000 - 2000,

            object.position.y = Math.random() * 4000 - 2000,

            object.position.z = Math.random() * 4000 - 2000,

            scene.add(object)



        objects.push(object);

    }

})

image.src = './static/img/sprite.png';

上面的代码中，我们创建了img标签，并使用CSS3DSprite将HTML元素转化为threejs的CSS3精灵模型，类似与转换成了three中的网格，并随机分布在-2000，2000的立方体中。

看下效果：

添加控制器

关于控制器，前面也已经介绍过啦，通过控制器，我们就可以改变相机的位置，观察不同角度的物体。

// 定义控制器

let controls;

controls = new TrackballControls( camera, renderer.domElement );



// 渲染  

function animate() {

    ...

    controls.update();

    ...

}

注意哦，controls.update需要防止在animate中，每帧执行。

有了控制器。我们就可以实现交互啦：

让小球按规律放大缩小

让小球按照正弦时间，放大缩小，即有一种闪烁的效果：

const time = performance.now();



for (let i = 0, l = objects.length; i < l; i++) {

    const object = objects[i];

    const scale = Math.sin((Math.floor(object.position.x) + time) * 0.002) * 0.3 + 1;

    object.scale.set(scale, scale, scale);

}

让小球生成特定图形

生成矩形，对应的每个小球坐标：

const amount = 8;

const separationCube = 150;

const offset = ( ( amount - 1 ) * separationCube ) / 2;



for ( let i = 0; i < particlesTotal; i ++ ) {



    const x = ( i % amount ) * separationCube;

    const y = Math.floor( ( i / amount ) % amount ) * separationCube;

    const z = Math.floor( i / ( amount * amount ) ) * separationCube;



    positions.push( x - offset, y - offset, z - offset );



}

tween.js使用

const position = {x: 0,y: 0};

;//创建一段tween动画

const tween = new TWEEN.Tween(position)

//经过2秒，position对象的x和y属性分别从零变化为100、50

tween.to({x: 100,y: 50}, 2000);

//tween动画开始执行

tween.start();

// 动画效果  类似annimation

tween.easing()

// 完成时执行的钩子，里面可以继续执行下一个操作

tween.onComplete()

使杂乱的小球变成矩形

import * as THREE from 'three';

// tween动画库

import TWEEN from 'three/addons/libs/tween.module.js';

//通过轨迹球控件TrackballControls 我们可以实现场景的旋转、缩放、平移等功能

import { TrackballControls } from 'three/addons/controls/TrackballControls.js'

// 雪碧图

import { CSS3DRenderer, CSS3DSprite } from 'three/addons/renderers/CSS3DRenderer.js'



// 定义场景、相机、渲染器

let scene, camera, renderer;

// 定义控制器

let controls;



// 定义小球数量

const particlesTotal = 512;

// 定义位置

const positions = [];

// 定义物体

const objects = []

let current = 0;

// 初始化

init()

// 渲染

animate();



function init() {

    // 透视相机  远端距离最好设大一点  不然会展示不全

    camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 10000);

    // 相机位置

    camera.position.set(600, 400, 1500);

    // 相机朝向位置

    camera.lookAt(0, 0, 0);





    scene = new THREE.Scene();



    const image = document.createElement('img');

    image.addEventListener('load', () => {

        for (let i = 0; i < particlesTotal; i++) {

            //   cloneNode() 方法可创建指定的节点的精确拷贝

            const object = new CSS3DSprite(image.cloneNode())

            // 随机分布位置 -2000 2000的立方体内

            object.position.x = Math.random() * 4000 - 2000,

                object.position.y = Math.random() * 4000 - 2000,

                object.position.z = Math.random() * 4000 - 2000,

                scene.add(object)



            objects.push(object);

        }

        transition()

    })

    image.src = './static/img/sprite.png';



    // cube

    const amount = 8;

    const separationCube = 150;

    const offset = ((amount - 1) * separationCube) / 2;



    for (let i = 0; i < particlesTotal; i++) {



        const x = (i % amount) * separationCube;

        const y = Math.floor((i / amount) % amount) * separationCube;

        const z = Math.floor(i / (amount * amount)) * separationCube;



        positions.push(x - offset, y - offset, z - offset);



    }



    // 渲染画布

    renderer = new CSS3DRenderer();

    renderer.setSize(innerWidth, window.innerHeight);

    document.getElementById('container').appendChild(renderer.domElement);



    controls = new TrackballControls(camera, renderer.domElement);



}





// 动画

function transition() {

    const offset = current * particlesTotal * 3;

    const duration = 2000;

    for (let i = 0, j = offset; i < particlesTotal; i++, j += 3) {

        const object = objects[i];

        new TWEEN.Tween(object.position)

            .to({

                x: positions[j],

                y: positions[j + 1],

                z: positions[j + 2]

            }, Math.random() * duration + duration)

            .easing(TWEEN.Easing.Exponential.InOut)

            .start();

    }

    new TWEEN.Tween(this)

        .to({}, duration * 3)

        .onComplete(transition)

        .start();

    current = (current + 1) % 4;

}



// 渲染

function animate() {

    requestAnimationFrame(animate);

    controls.update();

    TWEEN.update();



    // 让小球按照正弦时间，放大缩小

    const time = performance.now();



    for (let i = 0, l = objects.length; i < l; i++) {



        const object = objects[i];

        const scale = Math.sin((Math.floor(object.position.x) + time) * 0.002) * 0.3 + 1;

        object.scale.set(scale, scale, scale);



    }

    renderer.render(scene, camera)

}

杂乱的小球变成多种形态完整代码

限制文件大小啦，没法完全展示，大家自行运行看看吧！

<div id="container"></div>

<script type="module">

    import * as THREE from 'three';

    // tween动画库

    import TWEEN from 'three/addons/libs/tween.module.js';

    //通过轨迹球控件TrackballControls 我们可以实现场景的旋转、缩放、平移等功能

    import { TrackballControls } from 'three/addons/controls/TrackballControls.js'

    // 雪碧图

    import { CSS3DRenderer, CSS3DSprite } from 'three/addons/renderers/CSS3DRenderer.js'



    // 定义场景、相机、渲染器

    let scene, camera, renderer;

    // 定义控制器

    let controls;



    // 定义小球数量

    const particlesTotal = 512;

    // 定义位置

    const positions = [];

    // 定义物体

    const objects = []

    let current = 0;

    // 初始化

    init()

    // 渲染

    animate();



    function init() {

        // 透视相机  远端距离最好设大一点  不然会展示不全

        camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 10000);

        // 相机位置

        camera.position.set(600, 400, 1500);

        // 相机朝向位置

        camera.lookAt(0, 0, 0);





        scene = new THREE.Scene();



        const image = document.createElement('img');

        image.addEventListener('load', () => {

            for (let i = 0; i < particlesTotal; i++) {

                //   cloneNode() 方法可创建指定的节点的精确拷贝

                const object = new CSS3DSprite(image.cloneNode())

                // 随机分布位置 -2000 2000的立方体内

                object.position.x = Math.random() * 4000 - 2000,

                    object.position.y = Math.random() * 4000 - 2000,

                    object.position.z = Math.random() * 4000 - 2000,

                    scene.add(object)



                objects.push(object);

            }

            transition()

        })

        image.src = './static/img/sprite.png';



        // Plane

        const amountX = 16;

        const amountZ = 32;

        const separationPlane = 150;

        const offsetX = ((amountX - 1) * separationPlane) / 2;

        const offsetZ = ((amountZ - 1) * separationPlane) / 2;

        for (let i = 0; i < particlesTotal; i++) {

            const x = (i % amountX) * separationPlane;

            const z = Math.floor(i / amountX) * separationPlane;

            const y = (Math.sin(x * 0.5) + Math.sin(z * 0.5)) * 200;

            positions.push(x - offsetX, y, z - offsetZ);

        }



        // Cube

        const amount = 8;

        const separationCube = 150;

        const offset = ((amount - 1) * separationCube) / 2;

        for (let i = 0; i < particlesTotal; i++) {

            const x = (i % amount) * separationCube;

            const y = Math.floor((i / amount) % amount) * separationCube;

            const z = Math.floor(i / (amount * amount)) * separationCube;

            positions.push(x - offset, y - offset, z - offset);

        }



        // Random

        for (let i = 0; i < particlesTotal; i++) {

            positions.push(

                Math.random() * 4000 - 2000,

                Math.random() * 4000 - 2000,

                Math.random() * 4000 - 2000

            );

        }



        // Sphere

        const radius = 750;

        for (let i = 0; i < particlesTotal; i++) {

            const phi = Math.acos(- 1 + (2 * i) / particlesTotal);

            const theta = Math.sqrt(particlesTotal * Math.PI) * phi;

            positions.push(

                radius * Math.cos(theta) * Math.sin(phi),

                radius * Math.sin(theta) * Math.sin(phi),

                radius * Math.cos(phi)

            );

        }



        // 渲染画布

        renderer = new CSS3DRenderer();

        renderer.setSize(innerWidth, window.innerHeight);

        document.getElementById('container').appendChild(renderer.domElement);

        controls = new TrackballControls(camera, renderer.domElement);

    }





    // 动画

    function transition() {

        const offset = current * particlesTotal * 3;

        const duration = 2000;

        for (let i = 0, j = offset; i < particlesTotal; i++, j += 3) {

            const object = objects[i];

            new TWEEN.Tween(object.position)

                .to({

                    x: positions[j],

                    y: positions[j + 1],

                    z: positions[j + 2]

                }, Math.random() * duration + duration)

                .easing(TWEEN.Easing.Exponential.InOut)

                .start();

        }

        new TWEEN.Tween(this)

            .to({}, duration * 3)

            .onComplete(transition)

            .start();

        current = (current + 1) % 4;

    }



    // 渲染

    function animate() {

        requestAnimationFrame(animate);

        controls.update();

        TWEEN.update();



        // 让小球按照正弦时间，放大缩小

        const time = performance.now();



        for (let i = 0, l = objects.length; i < l; i++) {



            const object = objects[i];

            const scale = Math.sin((Math.floor(object.position.x) + time) * 0.002) * 0.3 + 1;

            object.scale.set(scale, scale, scale);



        }

        renderer.render(scene, camera)

    }



</script>

逛 V 站刷到一个北漂的码农，他的生存指南直接让我破防，但也不得不佩服他的生存能力和心态。

先介绍下这位老哥的情况，普通本科非科班，9 年 IOS 开发经验，其中 1 年 RN，一年 flutter。北漂，名下无车，老婆和孩子都在北京，目前孩子在读幼儿园。

上半年已经被优化裁员了，更新简历重新找工作，整体情况就是一周打招呼几十次，只成功投了 3 份简历，0 次面试。

实在不敢想象几个月没工作心态会崩成啥样。虽然没有做好心理准备，但也没有别的办法了。

社保代缴违法了也断缴了，每个月剩下 3k 左右，够孩子上两个月的幼儿园。

失业一段时间之后，注册了滴滴代驾，等待审核通过之后打算买一个折叠自行车。

发现北京的滴滴代驾已经没有名额了，只能等缺人的时候才能继续走下一步操作。

然后注册了美团众包，新手第一天还得培训，培训完才能接单。

之后便开始做起了外卖员，第一次跑从早上 5 点到 7 点 50 分，跑了 6 单 ，15km 的路程，一共赚了 44 元，如果扣除保险的就是 41 元，时薪则是 16.4 元。

由于刚开始，并不累，只是觉得有点意思，目前心态还算好。有一个好处就是，不会觉得挣钱很容易了，坐办公室一天就是几百上千。

之所以会优先选择代驾和外卖的原因，是因为今年的行情的确很糟糕，找了几个月的工作还没找到，感觉这次的找工作周期并不短。

另一个原因是时间比较自由，不会影响我学习和面试。开发这行我也比较热爱，不愿意丢弃这份工作。

并不是说找工作期间完全找不到工作。而是找的工作降薪太多，从企业的角度来说不稳定的因素也有。自己也不甘心，一旦降下去很难说下次按上次的高薪去涨。

由于北京代驾排队人数较多，暂时没有开放名额，所以入职了美团和小鸟。

从 5 月份 12 号开始跑，一开始基本上早上 5 点到 7 点 20 这段时间，然后回家接孩子上幼儿园。

只跑早上，是因为白天还得学习，后来发现没一个面试，索性白天时间段也开始跑了。

5 月份跑单统计下来，美团 275 单，一共 1900 元，扣了 180 元，有一次上午的单子已经餐损了，结果下午又流转到我这新手的头上了，由于没有经验不会操作导致餐损和违规算到我头上了，反馈给客服也不顶用。

蜂鸟 44 单，一共 280 元，扣除 20 元的保险和超时扣费。

每小时基本 20 元左右，叠加活动奖励差不多能到 26.7 元一小时，基本上 1元/km。这个 km 不止是单纯商家到顾客的距离，还要加上骑手接单时的位置到商家的距离。

所用的工具就是一辆最高 25km/h 的国标电动车。所以同时最多挂3单，那些车速快的我看到能接 9 单。没解速是因为觉得外卖只是暂时的，解速以后带孩子骑行就不安全了。

跑外卖整体的收获就是，觉得挣钱不容易，远不如之前坐办公室一天就好几百。甚至觉得跑外卖的时候还期盼下雨，因为会有天气补贴，1 单有 0.5-1 元的补贴，自己想想都觉得心酸。

但也没有那么焦虑了，虽然不够房租和日常开销，但好歹能够也算有收入。其实内心也是有点焦虑，不过在家里就是不能表现得太明显。

我比较喜欢开车，所以还是会去跑代驾。由于滴滴排队太慢了，到现在还在排队中，就先加入了别的代驾。

做代驾前，我做了一些功课。在抖音上搜各种档式，包括鸡腿挡、怀挡、旋钮挡等。还有各种车的启动方式，比如宝马、奔驰、路虎、特斯拉等。

心理建设还是有的，毕竟是开别人的车，怕刮蹭出事故。自己第一次上线接单前足足鼓励了半小时。

我没有买电动车和自行车，靠地铁和共享单车。因此接单我都跑市里，从 2 环到 4 环，跑偏僻地方的概率很小，不至于给我干到廊坊回不来。

刚开始的时候  14 点就出门，但是基本上 19 点开始才可能有单，再加上后来回家晚，第二天可能要补觉，所以基本上就是晚上 20 点到 凌晨。

且家里住的比较远，基本上到家都在凌晨1点半以上，最晚曾到凌晨4点。

整体收入，没接过 200 元以上得大单，所以时薪在 0-120 元左右。由于单量不稳定，有时候要等个把小时才来单，现在每天差不多几十到 100元 不等。

有一次接了一个 300+ 的大单，预计开车 1 小时多点，但是被取消了，有点心痛！

与外卖相比大概率好点，除非代驾没单或者外卖有活动。

近两个月找工作情况，一共3个面试，其中2 个内推，1 个网投。一个非大厂，终面挂，2 个大厂，分别一面挂和二面挂。

目前已经降薪 30% 在找了，但是还没有找到，笑哭。

同时也在继续开发自己的 APP，由于苹果账号到期了所以现在还没搜到。目前正在做得内容有 商品码识别、小组件和内购，希望掌握技能的同时增加收入。

看到这里，我默默的问一句，大家眼中的失业潮是怎样的？

看了不少的消息，基本上有一个共同的意识就是，环境不太好，都在挣扎做一些副业之类挣额外的收入来维持。

另外代驾和外卖数量逐渐开始到达红线的消息传来，也不是空穴来潮。

我所在的开发团队，也都有一个共同意识，就是做好留一手的准备，该考驾-照的考驾-照，该练体力的练体力，该做其他准备的做其他准备。

公司个月都在汇报信息化建设程度，我们疯狂给他们开发系统，开发工具，省人省力省成本。

做到了一定程度竟然听到在清算人力，听到之后不禁打了个寒颤，至少我也是帮凶了吧。

文中主人公 V 站地址👉：http://www.v2ex.com/t/956789

设想一种场景，有两个组件，这两个组件在初始化阶段，都需要调用同一个 API 接口去获取数据。为了防止请求冗余，可以把两个组件的请求都挪到父组件中，由父组件统一调用一次请求，然后再将响应的数据结果传给两个子组件。这种方法应该是最常见的，不过它也有一个局限性条件：两个组件必须有一个共同的祖先组件，如果这两个组件是同级的兄弟组件倒也还好，如果非同级，那么数据的传参就会有些麻烦了。那么还有其他办法吗？当然是有的。

我们可以换个思路，每个组件还是保持原有的业务逻辑不变，从请求接口处做文章。既然是同一个接口调用了两次，而且还是返回了相同的请求结果，那么不妨在第一次时调用成功时，就把请求结果缓存起来，等到第二次再调用时，直接返回缓存的数据。按照这个思路可以写出第一版的代码（这里用了 TS 方便查看参数的类型）：

/**

 * 缓存请求的响应结果

 * 把发起请求的 Promise 对象挂载在原型对象上

 * @param request 请求函数

 */

function cacheRequest<T>(request: (...args: any[]) => Promise<T>) {

  const cache = Symbol("cache")

  return function (...args: any[]): Promise<T> {

    if (!request.prototype[cache]) {

      request.prototype[cache] = request(...args)

    }

    return request.prototype[cache]

  }

}

• 首先 cacheRequest 函数，需要接收一个参数 request，request 是一个返回结果为 Promise 对象的函数。cacheRequest 执行完后返回一个新的匿名函数。


• 然后，在匿名函数的内部，先判断 request 的原型对象上是否有 cache（这里的 cache 使用了 Symbol 类型，确保键名唯一）。也即，是否有缓存过的请求结果，如果没有，说明是第一次调用，则将 request 的执行结果存到缓存里。如果有缓存，则直接返回缓存。


• 可以看到，缓存也是一个 Promise 类型。在同时调用多次请求时，只要在第一次调用执行后，已经把 Promise 存到缓存里了，后续的请求返回的也是缓存里的 Promise，从而保证多个请求都指向同一个 Promise ，也即只会调用一次 API 接口。


• 这里需要注意一点，由于需要往 request 的原型对象上挂载缓存，所以 request 不能是箭头函数。因为箭头函数没有 this，也就意味着没有原型对象。

小测一下：

function cacheRequest(request) {

  const cache = Symbol("cache")

  return function (...args) {

    if (!request.prototype[cache]) {

      request.prototype[cache] = request(...args)

    }

    return request.prototype[cache]

  }

}



const request = function () {

  return new Promise(resolve => {

    console.log("fetch request")

    setTimeout(resolve, 2000)

  })

}



const newRequest = cacheRequest(request)



newRequest()

newRequest()

newRequest()

可以看到虽然 newRequest 调用了三次，但是 fetch request 只打印了一次，也就是说 request 只调用了一次，符合预期！但是，最后一次 newRequest 的调用，是在 3 秒后调用的，也是走的缓存，没有重新执行。仔细思考一下，后续无论什么时候调用 newRequest 都会使用缓存里的数据，不会重新调用请求了，这显然是不合理的。我们还需要加个缓存的过期时间，超过这个时间，就重新发起新的请求。第二版如下：

/**

 * 缓存请求的响应结果

 * 把发起请求的 Promise 对象挂载在原型对象上

 * 保证在 cacheTime 时间间隔内的多次请求，只会调用一次

 * @param request 请求函数

 * @param cacheTime 最大缓存时间（单位毫秒）

 */

export function cacheRequest<T>(request: (...args: any[]) => Promise<T>, cacheTime = 1000) {

  const cache = Symbol("cache")

  const lastTime = Symbol("lastTime")

  return function (...args: any[]): Promise<T> {

    if (!request.prototype[cache] || Date.now() - request.prototype[lastTime] >= cacheTime) {

      request.prototype[cache] = request(...args)

      request.prototype[lastTime] = Date.now()

    }

    return request.prototype[cache]

  }

}

• 首先，cacheRequest 新增一个入参 cacheTime，用于设置过期时间，默认为 1 秒。


• 其次，在原型对象上新增了一个 lastTime 属性，用来记录最后一次调用的时间。


• 当缓存为空，或者当前时间距离上一次调用时间超过缓存过期时间时，更新 cache 和 lastTime 。

再来小测一下：

function cacheRequest(request) {

  const cache = Symbol("cache")

  const lastTime = Symbol("lastTime")

  return function (...args) {

    if (!request.prototype[cache] || Date.now() - request.prototype[lastTime] >= cacheTime) {

      request.prototype[cache] = request(...args)

      request.prototype[lastTime] = Date.now()

    }

    return request.prototype[cache]

  }

}



const request = function () {

  return new Promise(resolve => {

    console.log("fetch request")

    setTimeout(resolve, 2000)

  })

}



const newRequest = cacheRequest(request)



newRequest()

newRequest()

setTimeout(newRequest, 3000)

这一次，fetch request 打印了两次，符合预期，完美！

引言

大家好，我是亿元程序员，一位有着8年游戏行业经验的主程。

今天我想和大家分享一个有趣的故事。这个故事的主角是我的一个朋友，他是一位资深的软件工程师，月薪高达5万。你可能会觉得这个收入水平的人应该过着无忧无虑的生活，但是他告诉我，他的工作压力非常大，尤其是在处理BUG的时候。

BUG是什么

BUG，这个词在软件开发中是非常常见的。它是计算机程序中的一个错误或问题，可能会导致程序无法正常运行。对于软件工程师来说，找到并修复这些BUG是一项非常重要的任务。

心得

我这位朋友告诉我，他在处理BUG的过程中，有以下几点心得：

1. 
   

   耐心：找到并修复BUG需要非常强的耐心。有时候，你可能需要花费几个小时，甚至几天的时间来追踪一个BUG的来源。这需要你有足够的耐心去面对这个问题。

   
   


2. 
   

   细心：在处理BUG的过程中，你需要非常细心。因为BUG可能隐藏在程序的任何一个地方，只有通过仔细的检查，才能找到它。

   
   


3. 
   

   创新：有时候，传统的解决方法可能无法解决某个BUG。这时候，你需要有创新的思维，去寻找新的解决方案。

   
   


4. 
   

   团队协作：处理BUG并不是一个人的事情，而是需要整个团队的协作。每个人都有自己的专长，只有通过团队的协作，才能更有效地解决问题。

   
   


5. 
   

   不断学习：技术是不断发展的，新的编程语言、新的开发工具、新的开发方法会不断出现。作为软件工程师，你需要不断学习，才能跟上技术的发展。

   
   

我这位朋友的心得让我深受启发。他告诉我，虽然处理BUG的过程可能会很艰难，但是当你成功解决一个问题的时候，那种成就感是无法用言语表达的。

我的看法

首先，让我们来谈谈耐心。在游戏开发中，找出BUG的来源是一项非常复杂的任务。你可能需要查看大量的代码，甚至需要反复测试多次，才能找到问题的根源。这个过程可能会非常耗时，但是没有耐心的话，你可能会错过一些重要的线索。因此，耐心是处理BUG的第一步。

其次，细心也是非常重要的。在编写代码的过程中，程序员可能会犯一些错误，这些错误可能会导致程序无法正常运行。这些错误可能是语法错误，也可能是逻辑错误。只有通过仔细的检查，才能找到这些错误。因此，细心是处理BUG的第二步。

接下来，我们来谈谈创新。在游戏开发中，传统的解决方法可能无法解决某些复杂的问题。这时候，你需要有创新的思维，去寻找新的解决方案。例如，你可以尝试使用新的编程语言或者新的开发工具来解决问题。因此，创新是处理BUG的第三步。

然后，我们来谈谈团队协作。在游戏开发中，处理BUG并不是一个人的事情，而是需要整个团队的协作。每个人都有自己的专长，只有通过团队的协作，才能更有效地解决问题。例如，设计师可以帮助程序员理解用户的需求，测试人员可以帮助程序员发现程序的问题。因此，团队协作是处理BUG的第四步。

最后，我们来谈谈不断学习。技术是不断发展的，新的编程语言、新的开发工具、新的开发方法会不断出现。作为游戏开发者，你需要不断学习，才能跟上技术的发展。只有这样，你才能更好地处理BUG。因此，不断学习是处理BUG的最后一步。

结语

总的来说，处理BUG是一项需要耐心、细心、创新、团队协作和不断学习的任务。虽然这个过程可能会很艰难，但是当你成功解决一个问题的时候，那种成就感是无法用言语表达的。

希望这些心得能对你们有所帮助。

在哪里可以看到如此清晰的思路，快跟上我的节奏！关注我，和我一起了解游戏行业最新动态，学习游戏开发技巧。

我是"亿元程序员"，一位有着8年游戏行业经验的主程。在游戏开发中，希望能给到您帮助, 也希望通过您能帮助到大家。

AD:笔者线上的小游戏《重力迷宫球》《贪吃蛇掌机经典》《填色之旅》大家可以自行点击搜索体验。

写在前面

废掉一个人，其实还是挺简单的。最简单的两种方式就是：让他忙，一直忙；让他闲，一直闲。

一个人开始废掉的标志

终日懒散，无所事事；没有目标，没有规划；不想上班，只想打游戏；除了这些，可能下一个将要废掉的人，就是看似每天都很忙碌的你！

冰河在多年的从业生涯中，总结出10条序员如何让自己废掉的铁律。大家对号入座。

如何让自己更快的废掉？

忙得要死

有人说，废掉一个程序员最隐蔽的方式，就是让他忙到没有时间成长。每天定的计划特别满，正常工作时间完不成的，必须留下来加班。程序员每天都要很努力的工作，不停的coding，写业务代码。每天都非常忙碌，甚至周末都不能休息。有些公司“996”还不行，还要弄个“007”出来，程序员完全无法留出时间自我总结和成长。

冰河见过太多这样的人了，工作几年了，只会写CRUD。为哈？因为他太忙了，忙到没有时间提升自己。很多工作三年的程序员就只会CRUD。跳槽面试时，一旦被问到性能调优、高并发、Dubbo、SpringCloud等底层的原理和技术时，基本就歇菜了。

闲得要命

有人说，废掉一个程序员最快的方式，是让他闲着，让他没有方向感，不知道干啥。这类程序员也不会规划自己的时间，只是被动的接受别人的安排。时间久了，忘记了自己是干啥的，成功的废掉了自己。

拖延症

这类程序员就是自己把自己拖死的。工作任务不重，但是每天会加班到很晚，开始觉得很勤奋，但是细想，就这点工作不至于加班这么久吧？一问才知道，这是拖延症的表现。有些程序员做事情喜欢拖延，工作前要先聊会QQ，聊会微信，看看微博，刷刷朋友圈。总觉得时间还早，晚点再干吧。久而久之，养成了难以戒掉的拖延症。

吃老本

不及时更新自己的技术栈，拒绝接受新技术。总觉得自己的技术很牛X，殊不知，你的技术已经赶不上时代的潮流了，刚毕业的小学生掌握的技术都比你先进。

不会规划

对自己的职业生涯没有规划，未来朝着哪些方向努力，完全不知道。当一天和尚，撞一天钟。一旦公司或者企业出现变故，这类程序员基本没戏。

没有目标

这点与不会规划有些雷同，但是更加强调的是目标感。没有目标感，无法更好的驱动自己去完成相应的事项，无法让自己更聚焦到优先级高的事项中，即使再忙，也是眉毛胡子一把抓，最后累苦了自己，还拖累了别人。

自我感觉良好

这类程序员就是自我感觉啥都会，将自己封闭在自身的世界中，不愿意与他人沟通和交流，觉得自己都是对的，就这么干！美其名曰：自我良好！实际上，啥也不是。久而久之，不废才怪！

专注度不够

做事情注意力不集中，写两行代码，看看手机、刷刷微博和朋友圈，无法让自己专注的完成手上的任务。时间久了，养成了三心二意的习惯。

知识面欠缺

不愿拓宽自己的技术栈，发自内心愿意当一颗小小的螺丝钉，不愿意尝试新技术和新业务，守着自己的一亩三分地，反反复复就那些CRUD操作。

啥都想学

这类程序员本质上就是没有一个方向，对自己的职业生涯没有规划，啥都想学，一会想学Java，一会想学Python，一会又想学Go，最后又想学大数据。到头来，却是啥也没学会。

以上这些，希望小伙伴们有则改之，无则加勉~~

最后，除上面10条铁律外，还有一点就是 改需求 也能让程序员死得快些！

好了，今天就到这儿吧，小伙伴们，你们知道哪些能够让程序员更快废掉的方式呢？请在文末留言，说出你的观点。我是冰河，我们下期见~~

枚举（Enum）是一种有助于提高代码可读性和可维护性的数据类型，允许我们为一组相关的常量赋予有意义的名字。

在Python中，枚举类（Enum）提供了一种简洁而强大的方式来定义和使用枚举。

一、枚举类

1.1 什么是枚举类？

枚举类是一种特殊的数据类型，用于表示一组具有离散取值的常量。它将常量与有意义的名字关联起来，使得代码更易读、更易维护。枚举类的每个成员都有一个唯一的名称和一个关联的值。

枚举类的典型用例包括表示颜色、方向、状态、星期几等常量值。使用枚举可以增强代码的可读性，减少硬编码的风险。

1.2 Python中的枚举类

在Python中，使用内置模块enum来创建和使用枚举类。

enum模块提供了Enum类，允许定义自己的枚举类型。

二、定义和使用枚举类

2.1 定义枚举类

要定义一个枚举类，需要导入Enum类并创建一个继承自它的子类。在子类中，我们定义枚举成员，并为每个成员分配一个名称和一个关联的值。

示例代码：

from enum import Enum



class Color(Enum):

    RED = 1

    GREEN = 2

    BLUE = 3

在这个示例中，定义一个名为Color的枚举类，它有三个成员：RED、GREEN和BLUE，每个成员都有一个整数值与之关联。

2.2 访问枚举成员

定义枚举类，可以通过成员名来访问枚举成员。例如：

print(Color.RED)    # 输出：Color.RED

print(Color.GREEN)  # 输出：Color.GREEN

2.3 获取枚举成员的值

要获取枚举成员的关联值，可以使用成员的value属性。例如：

print(Color.RED.value)    # 输出：1

print(Color.GREEN.value)  # 输出：2

2.4 比较枚举成员

枚举成员可以使用相等运算符进行比较。可以直接比较枚举成员，而不必比较它们的值。例如：

color1 = Color.RED

color2 = Color.GREEN



print(color1 == color2)  # 输出：False

2.5 迭代枚举成员

使用for循环来迭代枚举类的所有成员。例如，要打印所有颜色的名称和值：

for color in Color:

    print(f"{color.name}: {color.value}")

2.6 将值映射到枚举成员

根据枚举成员的值来获取成员本身，可以通过枚举类的__members__属性来实现。

例如，要根据值获取Color枚举成员：

value = 2

color = Color(value)

print(color)  # 输出：Color.GREEN

三、枚举的最佳实践

第三部分：枚举的最佳实践

枚举是一种有用的数据类型，但在使用时需要遵循一些最佳实践，以确保代码的可读性和可维护性。

3.1 使用枚举代替魔术数字

在代码中使用枚举来代替魔术数字（不明确的常量值）可以增加代码的可读性。枚举为常量提供了有意义的名字，使得代码更容易理解。

例如，使用枚举来表示星期几：

from enum import Enum



class Weekday(Enum):

    MONDAY = 1

    TUESDAY = 2

    WEDNESDAY = 3

    THURSDAY = 4

    FRIDAY = 5

    SATURDAY = 6

    SUNDAY = 7

3.2 避免硬编码

尽量避免在代码中硬编码枚举成员的值。如果需要使用枚举成员的值，最好使用枚举成员本身而不是其值。这可以提高代码的可读性，使得代码更容易维护。

例如，避免这样的写法：

if day == 1:  # 避免硬编码

    print("Today is Monday")

而使用枚举成员：

if day == Weekday.MONDAY:  # 更具表现力

    print("Today is Monday")

3.3 使用枚举成员的名称

枚举成员的名称通常应该使用大写字母，以便与常规变量和函数名称区分开。这是一种约定，有助于提高代码的可读性。例如，使用RED而不是red。

3.4 考虑枚举成员的值类型

枚举成员的值通常是整数，但根据上下文和需求，可以选择不同的值类型，如字符串。选择适当的值类型可以使代码更具表现力。

3.5 考虑用法和上下文

在定义枚举时，考虑其用法和上下文。命名枚举成员和选择合适的值应该反映其在应用程序中的含义和用途。这有助于其他开发人员更容易理解和使用枚举。

3.6 枚举的不可变性

枚举成员是不可变的，一旦创建就不能更改其值。这有助于确保枚举成员的稳定性，并防止意外的修改。

遵循这些最佳实践可以帮助你有效地使用枚举，提高代码的可读性和可维护性。枚举是一种强大的工具，可以在代码中代替魔术数字，并提供有意义的常量名称。

总结

Python的枚举类是一种强大的工具，用于表示一组相关的常量，并提高代码的可读性和可维护性。通过枚举，我们可以为常量赋予有意义的名称，避免硬编码的值，以及更容易进行比较和迭代。

在实际编程中，枚举类可以提供一种清晰、可维护且更具表现力的方式来处理常量值。

正式声明：以下内容完全为道听途说，肆意杜撰。请勿对号入座，自寻烦恼。

老郑是一家IT公司的程序员，岗位是Python开发，负责处理并分析一些科学数据。

这一天，老郑在写代码，写一段如何读取.txt文件的代码。说来也奇怪，web前端从浏览器上传.txt文件给Java后端，Java收到文件后，读取内容，然后按照规则筛选一下字符串，再返回给前端展示，这也就结束了。

但是Java同事对这个任务，先是调研了一周，然后告诉主管，这个功能很难实现。主管一听，非常重视，他担心开发流程受到影响，连忙问该怎么办？Java人员说，建议用Python来做。他不但提出问题，也给出了解决方案。他说自己百度上搜了，采用Python是可以实现的。

主管将信将疑地去问老郑，如果用Python读取.txt文件，难不难？

老郑先是一怔，他心想用什么语言读取.txt都不难啊！老郑说不难，很简单。

此时，主管心里瞬间满天晴朗：原来Java说的是真的，用Python果然不难。

主管问：做这个功能……需要几天？

老郑回答说，单纯读文件很简单，关键是读取之后做什么处理啊？

主管说就是找到几个关键词，把关键词替换成*号就行了。

老郑说，3个小时就够了。

# 打开文件并读取内容

with open('test.txt', 'r', encoding='utf-8') as file:

    content = file.read()

# 替换字符串

content = content.replace('掘金', '*')

# 输出内容

print(content)

老郑怕用时太多，解释道，其实写代码用不了3个小时，主要是考虑到还需要对接和测试。

主管摇了摇头，说：不要这么着急，做工作一定要仔细，我给你1天的时间，你给我做出精品，一定要用工匠精神做出精品。

主管说，你写一个处理.txt文件的服务。Web将文件传给Java，Java再传给你，你处理完把数据告诉Java，Java再告诉前端。

老郑一听，这里面有Java。于是，他疑惑地问道：“为什么要这么麻烦？Java直接处理不行吗？”

主管笑了笑，说道：“老郑，你糊涂啊。Java要是能处理，我还来找你干啥，你说是不是呀？啊哈哈！”

说完，他背着手走了，仿佛解决了一个世纪大难题。他很满意。

后来，老郑听到Java在讨论工期。其中一项任务是Java对接老郑处理.txt的Python接口，Java给出的工期是3个工作日。

老郑感觉很意外，套个壳原样转发请求，需要3天？这不合理啊！

确实不合理。老郑他们公司有一个部门，叫技术总控部。里面人员的定位都是技术大牛，专门负责审核开发人员提报的工时。这项操作，可以防止小白过于轻视任务导致延误项目时间，也可以防止老油条夸大工时造成浪费。

技术总控部的大牛注意到了Java对接Python这项3天的任务。总控告诉Java：这项3天的任务，不合理。

Java开发者淡定地问道：哪个地方不合理？！

总控说：这个3天不合理。一项任务占用3天工时，说明这项任务拆分的还不够细致。你需要将任务拆得更细致一些，我们给出的规范，最小单位是0.5小时，最大单位是1天。

于是，Java开发将这项转发接口的任务，拆分成了3个子任务。

• 第1天：结合实际业务，完成网络请求从HTTP协议层面的组织和发送；


• 第2天：对应逻辑场景，实现Python接口返回值的网络层面接收；


• 第3天：根据前期对接，对齐Web前端、Python端与Java端；

技术总控看了看，满意地点了点头，好似察觉并改善了一项重大风险，又帮公司做了一件防患于未然的事情。

Java开发的工时获批了，他很满意。主管也满意，总控也满意，大家都非常满意。

董事长来视察，看到排得严丝合缝的工时链条，而且大家也都在写代码，也很满意。

老郑抬头看了看整个场面，他总感觉哪里有些不对劲，但又说不上来。这确实是一片欣欣向荣、和谐向上的景象。于是，他也满意地笑了笑：嘿嘿。

前言

个人项目开发创业半年有余，两个项目全部扑街，一无所获。

仔细想来其实也不是什么都没有得到，因为现状就是，我创业开始前能预想到的最坏情况，哪怕一毛钱都挣不到，但是也可以从中积累一些经验，比如微信小程序的开发经验。

我过去7年的工作都是在从事前端开发，从最开始从事IPTV 开发，用原生JS、JQuery 开发运行在机顶盒上JSP 页面；到18年，创建了项目组的第一个Vue 项目，那时候我才算是开始“现代”前端的工作；21年到上海，在新公司开始全面使用React + TS，也就是时至创业开始，我所有的工作技能，都是前端技术，后端相关的只有自己瞎折腾的项目，没有真正应用到实际项目中的，这次也算是逼着自己进步了一把。

技术选型

前端 - 后台管理系统：React + TS，用了Antd 的组件库提供的模板直接创建项目

前端 - 微信小程序：原生微信小程序开发 + Vant Weapp

服务端：微信云开发

为什么要选用以上技术栈，只有有一个原因，就是成本极低！非常低！并且很稳定，前后端全部用JS 搞定；后台管理系统部署在腾讯云的Web 应用托管上，直接免去运维工作。说个题外话，前几年自己搞个人网站的时候，服务器是薅的阿里云的羊毛，结果就是啥活都得自己干，用Express 框架开发的后端服务，用Nginx 做代理，结果并发超过100个 服务器直接挂掉。。

现在这一套技术栈，几乎没有学习成本，腾讯云的Web 应用托管集成了CI 工具，提交代码到线上分之后，自动部署，用了半年多，网站、小程序都没有挂掉过。（我真不是腾讯的托。。）

后台管理系统

React、TS、Antd 业务开发技术不多赘述，讲讲怎么在Web 端请求微信云开发的接口吧。

微信云开发提供了可访问云服务的Web Sdk，引入sdk 后，只需要进行简单的初始化，即可访问接口。

云开发登录授权配置，打开匿名登录

示例代码

处理请求

import cloudbase from "@cloudbase/js-sdk";

...

const env = ""; // 环境id

const clientId = ""; 终端id



// 创建实例

const app: any = cloudbase.init({

  env,

  clientId,

});



const auth = app.auth({

  persistence: "local",

});



...

// 请求方法

export const cloudFn = async (

  type: string,

  params?: any

): Promise<any> => {

  // 判断登录态

  if (!auth?.hasLoginState()) {

    localStorage.clear();

    await auth.signInAnonymously();

  }



  const res = await app.callFunction({

    name: "xxxx", // 云函数名称

    data: { type, data: options?. }, // 传参

    parse: isDev, // 环境

  });



  // 根据自己的业务方式处理返回数据

  ...

处理接口

import { cloudFn } from "@/utils";



export const xxx = (params: API.xxx) => {

  return cloudFn("name", params);

};

Web Sdk 官方文档：docs.cloudbase.net/api-referen…

部署

提交代码到部署分之后，会自动部署，访问web 应用托管，会提供一个默认访问的域名，可以直接访问，但是不推荐生产使用，只需要再配置一个域名就好了。

微信小程序

如果没有开发过微信小程序，去看一下官方文档，前端基本可以无成本上手，参照官方文档开发就好；为什么组件库选择Vant Weapp，基本补全了官方没有提供的组件，使用方式也很简单，实际使用后体验不错，值得推荐。

微信云开发

我用Java、python、node 都写过后端接口，对于一个前端来说，单论简单、好上手而言，微信云开发，我愿称之为YYDS！就两个字，简单！

官方提供了请求的方法，我对其简单的封装了一下，如果觉得不错，尽管拿去用，如果有不完善的，还请指正

示例代码

云函数入口 index.js

const user = require('./user);



exports.main = async (event, context) => {

  switch (event.type) {

    case "userGet":

    case "userUpdate":

      return await user.main(event, context);

  



    default:

      return {

        code: -1,

          msg: '接口不存在'

      }

  }

};

user 入口

const get = require("./get");

const update = require("./update");



exports.main = async (event) => {

  const apiType = event.type

  const data = event.data || {};



  if (apiType === 'userGet') {

    return await get.main(data);

  };



  if (apiType === 'userUpdate') {

    return await update.main(data);

  };

};

user/get.js

const {

  dbGet, // 通用get 方法 (见后问)

  filterParams, // 清除异常参数，比如空字符串，null 等

} = require("../../utils");

const check = require('./check');



exports.main = async (data) => {

  // 校验参数

  if (check(data)) return {

    code: -1,

    msg: check(data),

  }



  const params = {

    offset: data.offset,

    limit: data.limit,

    name: data.name,

  };





  // 模糊搜索

  if (params.name) {

    params.name = {

      $regex: ".*" + params.name,

      $options: "i",

    };

  }



  return await dbGet("user", filterParams(params));

};

user/update.js

const {

  dbUpdate

} = require("../../utils");

const check = require('./check');



exports.main = async (data) => {

  if (check(data)) return {

    code: -1,

    msg: check(data),

  }





  const params = {

    _id: data._id,

    name: data.name

  };



  return await dbUpdate("user", params);

};

utils.js

const cloud = require("wx-server-sdk");



// 初始化云环境

cloud.init({

  env: cloud.DYNAMIC_CURRENT_ENV,

});



const db = cloud.database();



async function dbGet(

  databaseTable, // 表名

  params, // 参数

  orderByKey = "", // 排序参数

  order = "desc" // 排序方式

) {

  const pageInfo = {

    offset: params.offset || 1,

    limit: params.limit || 10,

  };

  delete params.offset;

  delete params.limit;



  try {

    // 获取总数

    const resCount = await db

      .collection(databaseTable)

      .where(params)

      .count();

      

    const resCountData = formatRes(resCount) 

    if(resCount?.code !== 0) {

      return resCountData

    }

    

    // 总数是0，直接返回数据

    if(resCount?.data === 0) {

        return {

          code: 0,

          data: { data: [] },

          total: 0,

        }

    }

    

    // 获取数据

    const res = await db

      .collection(databaseTable)

      .where(params)

      .skip((pageInfo.offset - 1) * pageInfo.limit) // 分页

      .limit(pageInfo.limit) // 最多几条

      .orderBy(orderByKey, order) // 排序

      .get();

    

    // 处理返回数据

    const resData = formatRes(res);

    if(resData?.code === 0) {

        return {

          code: 0,

          data: {

            data: resData?.data || [],

            total: resCountData?.data || 0

          },

        }

    } else {

      return resData

    }

  } catch (error) {

    return {

      code: -2,

      data: null,

      msg: "请求失败",

    };

  }

}



async function dbUpdate(databaseTable, updateData) {

  let res;

  let isSuccess = false;

  try {

    const params = updateData;

    

    if (updateData._id) {

      // 编辑

      delete params._id;

      res = await db.collection(databaseTable).doc(updateData._id).update({

        data: params,

      });

      

      if (res.errMsg === "document.update:ok") {

        isSuccess = true;

      }

    } else {

      // 新增

      res = await db.collection(databaseTable).add({

        data: params,

      });

      

      if (res.errMsg === "collection.add:ok") {

        isSuccess = true;

      }

    }

    if (isSuccess) {

      return {

        code: 0,

        _id: res._id,

        msg: `${updateData._id ? "更新" : "新增"}数据成功`,

      };

    } else {

      return {

        code: -1,

        data: null,

        msg: `${updateData._id ? "更新" : "新增"}数据失败`,

      };

    }

  } catch (error) {

    return {

      code: -1,

      data: null,

      msg: `请求服务器失败，${updateData._id ? "新增" : "更新"}数据失败`,

    };

  }

}



function formatRes(res) {

  const cloudFnMsgList = ["document.get:ok", "collection.get:ok", "collection.count:ok"];



  if (cloudFnMsgList.includes(res?.errMsg)) {

    return {

      code: 0,

      data: res.data || res.total,

    };

  } else {

    return {

      code: -1,

      data: null,

      msg: "请求服务器失败",

    };

  }

}



module.exports = {

  dbGet,

  dbUpdate,

  formatRes,

};

差不多到此就结束了，Web 端的后台管理系统，微信小程序的后端接口实现了，并且可以互通，这种方式是我实践过，在保证业务、性能、稳定的前提下，最低成本的全栈开发方案，如果有其他更好的方案，欢迎讨论。

"将 JavaScript 代码写入 HTML 文件与将其单独写入 JavaScript 文件之间有一些考虑因素。下面是一些关于两种做法的优缺点和适用场景的讨论：

将 JavaScript 代码写入 HTML 文件的优点：

• 方便快捷：将 JavaScript 代码直接嵌入到 HTML 文件中可以节省创建和加载额外文件的时间，特别是对于小型项目或仅需少量 JavaScript 代码的情况。


• 直观可见：通过将 JavaScript 代码嵌入到 HTML 文件中，可以更容易地将其与相关的 HTML 元素和结构联系起来，使代码的逻辑更加清晰明了。

将 JavaScript 代码单独写入 JavaScript 文件的优点：

• 结构清晰：将 JavaScript 代码与 HTML 分离可以使代码结构更加清晰，提高代码的可读性和可维护性。这样做有助于保持 HTML 文件的简洁和专注于内容。


• 可重用性：将 JavaScript 代码存储在单独的文件中，可以使其在多个 HTML 文件中重复使用，提高代码的可重用性和一致性。


• 缓存优化：当 JavaScript 代码被单独提取到外部文件中时，浏览器可以将其缓存起来，从而提高页面加载速度并节省带宽。

综上所述，将 JavaScript 代码写入 HTML 文件适合小型项目或仅需少量 JavaScript 代码的情况，以及需要快速原型设计或简单交互的情况。而将 JavaScript 代码单独写入 JavaScript 文件适合大型项目或需要复杂的逻辑和结构的情况，以及需要提高代码的可读性、可维护性和可重用性的情况。根据项目的需求和规模，我们可以灵活选择适合的方式来组织和管理 JavaScript 代码。"

前言

不知道是否还有人记得，7年前的那个 「Android开源在线音乐播放器——波尼音乐」？

本来只是作为毕设项目，没想到很多人感兴趣，就断断续续的在维护，当时在网络上找到了一个百度开放的在线音乐 API，勉强实现了本地 + 网络播放能力。

可惜没过多久 API 就被百度关闭了，从此以后便黯然失色，一度沦落为本地播放器，在这个万物互联时代显得有点落寞，我也因此没有太多更新的动力。

最近无意间发现开源社区已经有大神发布了「网易云音乐 API」，喜出望外，遂有了重整旗鼓的想法，顺便对之前的架构做一次重构，来一次脱胎换骨的升级！

经过3个多月断断续续的开发，今天，它来了！

展示

视频

截图

功能

后续可能会根据需要增加功能

• 本地功能
  
  
  
  • 添加和播放本地音乐文件
  
  
  • 专辑封面显示
  
  
  • 歌词显示，支持拖动歌词调节播放进度
  
  
  • 通知栏控制
  
  
  • 夜间模式
  
  
  • 定时关闭
  
  
  
  


• 在线功能
  
  
  
  • 登录网易云
  
  
  • 同步网易云歌单
  
  
  • 每日推荐
  
  
  • 歌单广场
  
  
  • 排行榜
  
  
  • 搜索歌曲和歌单
  
  
  
  

体验

欢迎大家体验，如果发现功能问题或兼容性问题，可以在本文评论或者 GitHub Issue

环境要求

• Android 手机


• 电脑（非必须）

安装步骤

1. 搭建网易云服务器
   
   clone NeteaseCloudMusicApi 服务端项目到本地，根据项目说明安装并运行服务，需要确认电脑和手机处于同一局域网


2. 安装 APP
   
   点击下载最新安装包


3. 设置域名
   
   打开 APP，点击左上角汉堡按钮，打开抽屉，点击「域名设置」，输入步骤1中的地址（包含端口）


4. 设置完成即可体验

没有电脑，如何体验？

其实有一些同仁已经将网易云服务部署到公网了，我们可以直接用🐶。

这里不方便直接贴地址，下面教大家如何找到可以用的服务：

用 Google 搜索「网易云音乐API」，点击结果，如果页面是下图这样（注意：非作者的 GitHub.io 页面），恭喜，你找到了可以直接使用的服务，拷贝地址栏链接，输入到步骤3即可。

源码

wangchenyan/ponymusic: Android online music player use okhttp&gson&material design (github.com)

欢迎感兴趣的朋友 Star、Fork、PR，有你们的支持，我会非常开心😄

开源技术

站在巨人的肩膀上

• 页面：MVVM


• 网络：Retrofit


• 数据库：Room


• 依赖注入：Hilt


• 图片：Glide


• 统计&崩溃收集：Firebase


• 路由框架：wangchenyan/crouter: 支持组件化的 Android 路由框架


• 歌词控件：wangchenyan/lrcview: Android beautiful draggable lyric view library 一个优雅的可拖动歌词控件


• 启动任务：wangchenyan/init: Android 启动任务调度


• 通用库：wangchenyan/android-common: 个人使用的 Android 通用库


• RecyclerView Adapter：wangchenyan/radapter3: A multitype adapter for Android recyclerview