注册
环信即时通讯云

环信即时通讯云

单聊、群聊、聊天室...
环信开发文档

环信开发文档

Demo体验

Demo体验

场景Demo,开箱即用
RTE开发者社区

RTE开发者社区

汇聚音视频领域技术干货,分享行业资讯
技术讨论区

技术讨论区

技术交流、答疑
资源下载

资源下载

收集了海量宝藏开发资源
iOS Library

iOS Library

不需要辛辛苦苦的去找轮子, 这里都有
Android Library

Android Library

不需要辛辛苦苦的去找轮子, 这里都有

1.6kB 搞定懒加载、无限滚动、精准曝光

web
上文提到有很多类库在用 IntersectionObserver 实现懒加载,但更精准的描述是,IntersectionObserver 提供了一种异步观察目标元素与根元素(窗口或指定父元素)的交叉状态的能力,这项能力不仅能用来做懒加载,还可以提供无限滚动,精...
继续阅读 »

上文提到有很多类库在用 IntersectionObserver 实现懒加载,但更精准的描述是,IntersectionObserver 提供了一种异步观察目标元素与根元素(窗口或指定父元素)的交叉状态的能力,这项能力不仅能用来做懒加载,还可以提供无限滚动,精准曝光的功能。


1. IntersectionObserver 基础介绍


不管我们使用哪个类库,都需要了解 IntersectionObserver 的基本原理,下面是一个简单的例子



import React, { useEffect } from "react";
import "./page.css";

const Page1 = (props: { handleShowTypeChange: (type: number) => void }) => {
const { handleShowTypeChange } = props;

useEffect(() => {
const io = new IntersectionObserver((entries) => {
console.log(entries[0].intersectionRatio);
});

const footer = document.querySelector(".footer");

if (footer) {
io.observe(footer);
}

return () => {
io.disconnect();
};
}, []);

return (
<div className="scroll-container">
<button className="btn" onClick={() => handleShowTypeChange(0)}>
返回
</button>
<div className="placeholder">其他元素</div>
<div className="placeholder">其他元素</div>
<div className="placeholder">其他元素</div>
<div className="footer">被观察的元素</div>
</div>

);
};

export default Page1;

如上例,可以了解到以下几点知识




  1. new 一个 IntersectionObserver 对象,下称 io,需传入一个函数,下称 callbackcallback 的入参 entries 代表了正在被观察的元素数组,数组的每一项都拥有属性 intersectionRatio ,代表了被观察的元素与根元素可视区域的交叉比例,。




  2. 使用 ioobserve 方法来添加你想观察的元素,可以多次调用添加多个,




  3. 使用 iodisconnect 方法来销毁观测




使用上方的代码,可以完成对元素最基本的观察。如上方 gif 操作,在控制台可得到以下结果 ,




  • 进入页面时,callback 被调用了一次:intersectionRatio 为 0

  • 滚动到可视区,再次调用:intersectionRatio > 0

  • 滚动出可视区,再次调用:intersectionRatio 为 0

  • 滚动到可视区,再次调用:intersectionRatio > 0


而懒加载,无限滚动,精准曝光是如何基于这个 api 去实现的呢,如果直接去写,当然也能实现,但是会有些繁琐,下面引入本篇文章的主角:react-intersection-observer 类库,先看看这个类库的基本介绍吧。


2. react-intersection-observer 基础介绍


这个类库在全局维护了一个 IntersectionObserver 实例(如果只有一个根元素,那全局仅有一个实例,实际上代码中维护了一个实例的 Map,此处简单表述),并提供了一个名为 useInViewhooks 方便我们了解到被观测的元素的观测状态。与上面相同的例子,他的写法如下:


import React, { useEffect } from "react";
import { useInView } from 'react-intersection-observer';
import "./page.css";

const Page2 = (props: { handleShowTypeChange: (type: number) => void }) => {
const { handleShowTypeChange } = props;
const { ref } = useInView({
onChange: (inView, entry) => {
console.log(entry.intersectionRatio);
}
});

return (
<div className="scroll-container">
<button className="btn" onClick={() => handleShowTypeChange(0)}>
返回
</button>
<div className="placeholder">其他元素</div>
<div className="placeholder">其他元素</div>
<div className="placeholder">其他元素</div>
<div className="footer" ref={ref}>被观察的元素</div>
</div>

);
};

export default Page2;

如上例,使用更少的代码,就实现了相同的功能,而且带来了一些好处



  • 不用自己维护 IntersectionObserver 实例,既不用关心创建,也不用关心销毁

  • 不用控制被观察的元素到底是 entries 内的第几个,观察事件都会在相应绑定的 onChange 中进行回调


以上仅为基本使用,实战中需求是更为复杂的,所以这个类库也提供了一系列属性,方便大家的使用:



利用上面这些配置项,我们可以实现以下功能


3. 实战用例


3.1. 懒加载


import React from "react";
import { useInView } from "react-intersection-observer";
import "./page.css";

interface Props {
width: number;
height: number;
src: string;
}

const LazyImage = ({ width, height, src, ...rest }: Props) => {
const { ref, inView } = useInView({
triggerOnce: true,
root: document.querySelector('.scroll-container'),
rootMargin: `0px 0px ${window.innerHeight}px 0px`,
onChange: (inView, entry) => {
console.log('info', inView, entry.intersectionRatio);
}
});

return (
<div
ref={ref}
style={{
position: "relative",
paddingBottom: `${(height / width) * 100}%`,
background: "#2a4b7a",
}}
>

{inView ? (
<img
{...rest}
src={src}
width={width}
height={height}
style={{ position: "absolute", width: "100%", height: "100%", left: 0, top: 0 }}
/>

) : null}
</div>

);
};

const Page3 = (props: { handleShowTypeChange: (type: number) => void }) => {
const { handleShowTypeChange } = props;

return (
<div className="scroll-container">
<button className="btn" onClick={() => handleShowTypeChange(0)}>
返回
</button>
<div className="placeholder">其他元素</div>
<div className="placeholder">其他元素</div>
<div className="placeholder">其他元素</div>
<LazyImage width={750} height={200} src={"https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e4acf97e7dc944bf8ad5719b2b42f026~tplv-k3u1fbpfcp-watermark.image?"} />
</div>

);
};

export default Page3;

懒加载中我们需要用到几个额外的属性:




  • triggerOnce :只触发一次




  • root:默认为文档视口(如果被观察的元素,父/祖元素中有 overflow: scroll,需要指定为该元素)




  • rootMarginrootmargin




    • 同 css 上右下左写法,需要带单位,可简写('200px 0px')




    • 正值代表观察区域增大,负值代表观察区域缩小






在图片懒加载中,因为通常不可能等到元素被滚动到了可视区域,才开始加载图片,所以需要调整 rootMargin ,可以写为,rootMargin: `0px 0px ${window.innerHeight}px 0px ,这样图片可以提前一屏进行加载。


同样懒加载不需要不可见的时候回收掉相应的 dom ,所以只需要触发一次,设置 triggerOncetrue 即可。


3.2. 无限滚动



import React, { useState } from "react";
import { useInView } from "react-intersection-observer";
import "./page.css";

const Page4 = (props: { handleShowTypeChange: (type: number) => void }) => {
const { handleShowTypeChange } = props;
const [datas, setDatas] = useState([1, 1, 1]);
const { ref } = useInView({
onChange: (inView, entry) => {
console.log("inView", inView);
if (inView) {
setDatas((prevDatas) => [...prevDatas, ...new Array(3).fill(1)]);
}
},
});

return (
<div className="scroll-container">
<button className="btn" onClick={() => handleShowTypeChange(0)}>
返回
</button>
{datas.map((item, index) => {
return (
<div key={index + 1} className="placeholder">
第{index + 1}个元素
</div>
);
})}
<div className="load-more" ref={ref}></div>
</div>

);
};

export default Page4;

无限滚动主要依赖在 onChange 中对 inView 进行判断,我们可以添加一个高度为0的元素,名为 load-more ,当页面滚动到最下方时,该元素的 onChange 会被触发,通过对 inViewtrue 的判断后,加载后续的数据。同理,真正的无限滚动也需要提前加载(在观察内写异步请求等),也可以设置相应的 rootMargin ,让无限滚动更丝滑。


3.3. 精准曝光



import React from "react";
import { useInView } from "react-intersection-observer";
import "./page.css";

const Page5 = (props: { handleShowTypeChange: (type: number) => void }) => {
const { handleShowTypeChange } = props;
const { ref } = useInView({
threshold: 0.5,
delay: 500,
onChange: (inView, entry) => {
if (inView) {
console.log("元素需要上报曝光事件", entry.intersectionRatio);
}
},
});

return (
<div className="scroll-container">
<button className="btn" onClick={() => handleShowTypeChange(0)}>
返回
</button>
<div className="placeholder">其他元素</div>
<div className="placeholder">其他元素</div>
<div className="placeholder">其他元素</div>
<div className="footer" ref={ref}>
需要精准曝光的元素
</div>
</div>

);
};

export default Page5;

精准曝光也是很常见的业务需求,通常此类需求会要求元素的露出比例和最小停留时长。



  • 对露出比例要求的原因:因为有可能元素的有效信息并未展示,只是露出了一点点头,一般业务上会要求露出比例大于一半。

  • 对停留时长要求的原因:有可能用户快速划过,比如小说看到了很啰嗦的章节快速滑动,直接看后面结果,如果不加停留时长,中间快速滑动的区域也会曝光,与实际想要的不符。


类库恰好提供了下面两个属性方便大家的使用



  • threshold: 观察元素露出比例,取值范围 0~1,默认值 0

  • delay: 延迟通知元素露出(如果延迟后元素未达标,则不会触发onChange),取值单位毫秒,非必填。


使用上面两个属性,就可以轻松实现业务需求。


3.4. 官方示例


示例,官方示例中还有很多对属性的应用,比如 threshold 传入数组,skiptrack-visibility ,大家可自行体验。


总结


以上就是对 IntersectionObserver 以及 react-intersection-observer 的介绍了,希望能对大家有所帮助,文中录制的示例完整项目可以从此处获取。


作者:windyrain
来源:juejin.cn/post/7220309530910851130
收起阅读 »

字节都在用的代码自动生成

web
背景 如果有一份接口定义,前端和后端都能基于此生成相应端的代码,不仅能降低前后端沟通成本,而且还能提升研发效率。 字节内部的 RPC 定义主要基于 thrift 实现,thrift 定义了数据结构和函数,那么是否可以用来作为接口定义提供给前端使用呢?如果可以作...
继续阅读 »

背景


如果有一份接口定义,前端和后端都能基于此生成相应端的代码,不仅能降低前后端沟通成本,而且还能提升研发效率。


字节内部的 RPC 定义主要基于 thrift 实现,thrift 定义了数据结构和函数,那么是否可以用来作为接口定义提供给前端使用呢?如果可以作为接口定义,是不是也可以通过接口定义自动生成请求接口的代码呢?答案是肯定的,字节内部已经衍生出了多个基于 thrift 的代码生成工具,本篇文章主要介绍如何通过 thrift 生成前端接口调用的代码。


接口定义


接口定义,顾名思义就是用来定义接口的语言,由于字节内部广泛使用的 thrift 基本上满足接口定义的要求,所以我们不妨直接把 thrift 当成接口定义。


thrift 是一种跨语言的远程过程调用 (RPC) 框架,如果你对 Typescript 比较熟悉的话,那它的结构看起来应该很简单,看个例子:


namespace go namesapce

// 请求的结构体
struct GetRandomRequest {
1: optional i32 min,
2: optional i32 max,
3: optional string extra
}

// 响应的结构体
struct GetRandomResponse {
1: optional i64 random_num
}

// 定义服务
service RandomService {
GetRandomResponse GetRandom (1: GetRandomRequest req)
}

示例中的 service 可以看成是一组函数,每个函数可以看成是一个接口。我们都知道,对于 restful 接口,还需要定义接口路径(比如 /getUserInfo)和参数(query 参数、body 参数等),我们可以通过 thrift 注解来表示这些附加信息。


namespace go namesapce

struct GetRandomRequest {
1: optional i32 min (api.source = "query"),
2: optional i32 max (api.source =
"query"),
3: optional string extra (api.source = "body"),
}

struct GetRandomResponse
{
1: optional i64 random_num,
}

// Service
service RandomService {
GetRandomResponse GetRandom (1: GetRandomRequest req) (api.get = "/api/get-random"),
}

api.source 用来指定参数的位置,query 表示是 query 参数,body 表示 body 参数;api.get="/api/get-random" 表示接口路径是 /api/get-random,请求方法是 GET;


生成 Typescript


上面我们已经有了接口定义,那么对应的 Typescript 应该就呼之欲出了,一起来看代码:


interface GetRandomRequest {
min: number;
max: number;
extra: string;
}

interface GetRandomResponse {
random_num: number;
}

async function GetRandom(req: GetRandomRequest): Promise<GetRandomResponse> {
return request<GetRandomResponse>({
url: '/api/get-random',
method: 'GET',
query: {
min: req.min,
max: req.max,
},
body: {
extra: req.extra,
}
});
}


生成 Typescript 后,我们无需关心生成的代码长什么样,直接调用 GetRandom 即可。


架构设计


要实现基于 thrift 生成代码,最核心的架构如下:


image.png
因为 thrift 的内容我们不能直接拿来用,需要转化成中间代码(IR),这里的中间代码通常是 json、AST 或者自定义的 DSL。如果中间代码是 json,可能的结构如下:


{
name: 'GetRandom',
method: 'get',
path: '/api/get-random',
req_schema: {
query_params: [
{
name: 'min',
type: 'int',
optional: true,
},
{
name: 'max',
type: 'int',
optional: true,
}
],
body_params: [
{
name: 'extra',
type: 'string',
optional: true,
}
],
header_params: [],
},
resp_schema: {
header_params: [],
body_params: [],
}
}

为了保持架构的开放性,我们在核心链路上插入了 PrePlugin 和 PostPlugin,其中 PrePlugin 决定了 thrift 如何转化成 IR,PostPlugin 决定 IR 如何生成目标代码。


这里之所以是「目标代码」而不是「Typescript 代码」,是因为我希望不同的 PostPlugin 可以产生不同的目标代码,比如可以通过 TSPostPlugin 生成 Typescript 代码,通过 GoPostPlugin 生成 go 语言的代码。


总结


代码生成这块的内容还有很多可以探索的地方,比如如何解析 thrift?是找第三方功能生成 AST 还是通过 pegjs 解析成自定义的 DSL?多文件联编如何处理、字段名 case 如何转换、运行时类型校验、生成的代码如何与 useRequest 或 ReactQuery 集成等。


thrift 其实可以看成接口定义的具体实现,如果 thrift 不满足你的业务场景,也可以自己实现一套类似的接口定义语言;接口定义作为前后端的约定,可以降低前后端的沟通成本;代码生成,可以提升前端代码的质量和研发效率。


如果本文对你有启发,欢迎点赞、关注、留言交流。


作者:探险家火焱
来源:juejin.cn/post/7220054775298359351
收起阅读 »

前端怎么样限制用户截图?

web
做后台系统,或者版权比较重视的项目时,产品经常会提出这样的需求:能不能禁止用户截图?有经验的开发不会直接拒绝产品,而是进行引导。 先了解初始需求是什么?是内容数据过于敏感,严禁泄漏。还是内容泄漏后,需要溯源追责。不同的需求需要的方案也不同。来看看就限制用户截图...
继续阅读 »

做后台系统,或者版权比较重视的项目时,产品经常会提出这样的需求:能不能禁止用户截图?有经验的开发不会直接拒绝产品,而是进行引导。


先了解初始需求是什么?是内容数据过于敏感,严禁泄漏。还是内容泄漏后,需要溯源追责。不同的需求需要的方案也不同。来看看就限制用户截图,有哪些脑洞?


有哪些脑洞


v站和某乎上的大佬给出了不少脑洞,我又加了点思路。


1.基础方案,阻止右键保存和拖拽。


这个方案是最基础,当前可只能阻拦一些小白用户。如果是浏览器,分分钟调出控制台,直接找到图片url。还可以直接ctrl+p,进入打印模式,直接保存下来再裁减。


2.失焦后加遮罩层


这个方案有点意思,看敏感信息时,必须鼠标点在某个按钮上,照片才完整显示。如果失去焦点图片显示不完整或者直接遮罩盖住。


3.高速动态马赛克


这个方案是可行的,并且在一些网站已经得到了应用,在视频或者图片上随机插像素点,动态跑来跑去,对客户来说,每一时刻屏幕上显示的都是完整的图像,靠用户的视觉残留看图或者视频。即时手机拍照也拍不完全。实际应用需要优化的点还是挺多的。比如用手机录像就可以看到完整内容,只是增加了截图成本。


下面是一个知乎上的方案效果。(原地址):


image.png


正经需求vs方案


其实限制用户截图这个方案本身就不合理,除非整个设备都是定制的,在软件上阉割截图功能。为了这个需求添加更复杂的功能对于一些安全性没那么高的需求来说,有点本末倒置了。


下面聊聊正经方案:


1.对于后台系统敏感数据或者图片,主要是担心泄漏出去,可以采用斜45度七彩水印,想要完全去掉几乎不可能,就是观感比较差。


2.对于图片版权,可以使用现在主流的盲水印,之前看过腾讯云提供的服务,当然成本比较高,如果版权需求较大,使用起来效果比较好。


3.视频方案,tiktok下载下来的时候会有一个水印跑来跑去,当然这个是经过处理过的视频,非原画,画质损耗也比较高。Netflix等视频网站采用的是服务端权限控制,走的视频流,每次播放下载加密视频,同时获得短期许可,得到许可后在本地解密并播放,一旦停止播放后许可失效。


总之,除了类似于Android提供的截图API等底层功能,其他的功能实现都不完美。即使是底层控制了,一样可以拍照录像,没有完美的方案。不过还是可以做的相对安全。


你还有什么新思路吗?有的话咱评论区见,欢迎点赞收藏关注,感谢!


作者:正经程序员
来源:juejin.cn/post/7127829348689674253
收起阅读 »

Vue 实现接口进度条

web
前端在向后端请求信息时,常常需要等待一定的时间才能得到返回结果。为了提高用户体验,可以通过实现一个接口进度条函数来增加页面的交互性和视觉效果。 接口响应快 - 效果 接口响应慢 - 效果 实现思路 首先定义一个进度条组件来渲染页面展示效果,组件包含进度条背...
继续阅读 »

cover.png


前端在向后端请求信息时,常常需要等待一定的时间才能得到返回结果。为了提高用户体验,可以通过实现一个接口进度条函数来增加页面的交互性和视觉效果。



接口响应快 - 效果



接口响应慢 - 效果


实现思路


首先定义一个进度条组件来渲染页面展示效果,组件包含进度条背景、进度长度、以及进度数字,同时还要设置数据绑定相关属性,如进度条当前的百分比、动画执行状态、以及完成状态等。在请求数据的过程中,需要添加监听函数来监测数据请求的过程变化,并更新组件相应的属性和界面元素。


代码实现


下面是使用 Vue 实现一个接口进度条的栗子:


<template>
<div class="progress-bar">
<div class="bg"></div>
<div class="bar" :style="{ width: progress + '%' }"></div>
<div class="label">{{ progress }}%</div>
</div>
</template>

<script>
export default {
data() {
return {
progress: 0,
isPlaying: false,
isCompleted: false
}
},
mounted() {
this.start();
},
methods: {
start() {
this.isPlaying = true;
this.animateProgress(90)
.then(() => {
if (!this.isCompleted) {
this.animateProgress(100);
}
})
.catch((error) => {
console.error('Progress error', error);
});
},
animateProgress(target) {
return new Promise((resolve, reject) => {
let start = this.progress;
const end = target;
const duration = (target - start) * 150;

const doAnimation = () => {
const elapsed = Date.now() - startTime;
const progress = Math.min(elapsed / duration, 1);

this.progress = start + ((end - start) * progress);

if (progress === 1) {
resolve();
} else if (this.isCompleted) {
resolve();
} else {
requestAnimationFrame(doAnimation);
}
};

const startTime = Date.now();
requestAnimationFrame(doAnimation);
});
},
finish() {
this.isCompleted = true;
this.progress = 100;
}
}
};
</script>

<style scoped>
.progress-bar {
position: relative;
height: 8px;
margin: 10px 0;
}
.bg {
position: absolute;
top: 0;
left: 0;
width: 100%;
height: 100%;
background-color: #ccc;
border-radius: 5px;
}
.bar {
position: absolute;
top: 0;
left: 0;
height: 100%;
border-radius: 5px;
background-color: #409eff;
transition: width 0.5s;
}
.label {
position: absolute;
top: -20px;
left: calc(100% + 5px);
color: #333;
font-size: 12px;
}
</style>

首先定义了三个数据属性用于控制动画的播放和完成状态,分别是进度条当前比例 progress、动画播放状态 isPlaying、动画完成状态 isCompleted。在组件初始化的过程中,调用了 start 方法来启动进度条动画效果。在该方法内部,使用 Promise 来从 0% 到 90% 的百分比向相应位置移动,并在到达该位置时停止。


判断当前是否完成,如果没有完成则再次调用 animateProgress(100) ,并在进度加载期间检查是否有数据返回。若存在,则停止前半段动画,并使用1秒钟将进度条填充至100%。


下面讲解一下如何在请求数据的过程中添加监听函数:


import axios from 'axios';
import ProgressBar from './ProgressBar.vue';

const progressBar = new Vue(ProgressBar).$mount();
document.body.appendChild(progressBar.$el);

在这个代码片段中,使用了 Axios 拦截器来监听请求的过程。在请求开始之前,向页面添加进度条组件,之后将该组件挂载到页面中,并且将其元素追加到 HTML 的 <body> 标记尾部。


接下来,通过 onDownloadProgress 监听函数来监测下载进度的变化。如果加载完成则移除进度条组件。同时,也可以实现针对使用不同 API 的 ajax 请求设定不同的进度条,以达到更佳的用户体验效果。


axios.interceptors.request.use((config) => {    
const progressBar = new Vue(ProgressBar).$mount();
document.body.appendChild(progressBar.$el);

config.onDownloadProgress = (event) => {
if (event.lengthComputable) {
progressBar.progress = parseInt((event.loaded / event.total) * 100, 10);
if (progressBar.progress === 100) {
progressBar.finish();
setTimeout(() => {
document.body.removeChild(progressBar.$el);
}, 500);
}
}
};

return config;
}, (error) => {
return Promise.reject(error);
});

参数注入


为了能够灵活地调整接口进度条效果,可以使用参数注入来控制动画速度和完成时间的设定。在 animateProgress 函数中,使用传参来设置百分比范围和动画播放速度,从而得到不同进度条和播放时间的效果。


animateProgress(target, duration) {
return new Promise((resolve, reject) => {
let start = this.progress;
const end = target;

const doAnimation = () => {
const elapsed = Date.now() - startTime;
const progress = Math.min(elapsed / duration, 1);

this.progress = start + ((end - start) * progress);

if (progress === 1) {
resolve();
} else if (this.isCompleted) {
resolve();
} else {
requestAnimationFrame(doAnimation);
}
};

const startTime = Date.now();
requestAnimationFrame(doAnimation);
});
}

...

this.animateProgress(90, 1000)
.then(() => {
if (!this.isCompleted) {
this.animateProgress(100, 500);
}
})
...

在这个栗子中,将 duration 参数添加到 animateProgress 函数内部,并使用该参数来设置动画速度和完成时间。在第一个调用函数的时候,将异步进度条的播放时间设为 1000ms,从而得到速度较慢、完成时间较长的进度条效果。在第二个调用函数时,将进度条完成时间缩短为 500ms,并获得由此带来的更快动画效果。


总结


实现一个接口进度条函数可以提高网站性能和用户体验效果,同时也可以让页面更加交互性和生动有趣。在栗子中,使用了 Vue 框架来构建动画组件,使用了 Axios 拦截器来监听请求进度,使用了参数注入来控制动画速度和完成时间。


作者:𝑺𝒉𝒊𝒉𝑯𝒔𝒊𝒏𝒈
来源:juejin.cn/post/7225417805855916087
收起阅读 »

Js中异步代码挂起怎么解决?

web
从下面代码引入问题 function a() { console.log('aa'); } function b() { setTimeout(() => { //异步代码 console.log('bb'); ...
继续阅读 »

从下面代码引入问题


function a() {
console.log('aa');
}

function b() {
setTimeout(() => { //异步代码
console.log('bb');
}, 1000)
}

function c() {
console.log('cc');
}

a()
b()
c()

上述代码的执行结果为先打印'aa',再打印'cc',等一秒后再打印'bb'。哎?我们是不是就有疑问了,我们明显是先调用的函数a,再调用的函数b,最后调用的函数c,为什么函数b的打印结果最后才出来呢?这里我们要清楚的是函数b中定义了一个计时器,执行此代码是需要时间的,属于异步代码,当浏览器执行到此代码时,会先将此程序挂起,继续往下执行,最后才会执行异步代码。那要怎么解决此类问题呢?一个方法是将其他函数体内也定义一个计时器,这样也就会按顺序调用了,但是这样太不优雅了;还一个方法是函数c作为参数传入函数b,在函数b中执行掉,这样也不优雅。es6出来后就可以使用promise来解决此问题了。


js是一种单线程语言


什么是单线程?


我们可以理解为一次只能完成一个任务,如果有其他任务进来,那就需要排队了,一个任务完成了接着下一个任务。



因为js是一种单线程语言,任务是按顺序执行的,但是有时我们有多个任务同时执行的需求,这就需要异步编程的思想。



什么是异步?


当客户端发送给服务端请求时,在等待服务端响应的时候,客户端可以做其他的事情。


什么是异步模式调用? 


前一个任务执行完,调用回调函数而不是进行后一个任务。后一个任务不等前一个任务结束就执行,任务排列顺序与执行顺序无关。


什么是回调函数?


把函数当作参数传入另一个函数中,不会立即执行,当需要用这个函数时,再回调运行()这个函数。



以前是通过回调函数实现异步的,但是回调用多了会出现回调地狱,导致爆栈。



举个用回调函数来解决异步代码挂起问题


<body>
<div class="box">
<audio src="" id="audio" controls></audio> </audio>
</div>
<script>
//ajax
let url = ''
function getSong(cb) {
$.ajax({
url: ' 数据地址',
dataType: 'json',
success(res) {
console.log(res);
url = res[0].url
cb()
}
})
}
getSong(playSong)

function playSong() {
let audio = document.getElementById('audio')
window.addEventListener('click', () => {
audio.src = url
window.onclick = function () {
audio.play()
}
})
}

</script>
</body>

代码中用ajax向后端获取数据,这是需要时间的,属于异步代码,当我们分开调用这两个函数,函数getSong中的异步代码会出现挂起状态,导致函数playSong中的url获取不到值,会出现报错的情况,运用回调函数可以很好地解决这个问题。


Promise的使用


先执行一段代码


function xq() {

setTimeout(() => {
console.log('老王');
}, 2000)

}


function marry() {
setTimeout(() => {
console.log('老王结婚了');
}, 1000)
}


function baby() {
setTimeout(() => {
console.log('小王出生了');
}, 500)
}
xq()
marry()
baby()

结果为


1.png


???这是不是有点违背了道德,只能说老王是个渣男。这时候我们就需要使用promise对象来调整一下顺序了。


function xq() {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log('老王去相亲');
resolve('ok')
}, 2000)
})
}


function marry() {
return new Promise((resolve, reject) => {
setTimeout(() => {
console.log('老王结婚了');
resolve('ok')
}, 1000)
})
}


function baby() {
setTimeout(() => {
console.log('小王出生了');
}, 500)
}


// xq().then(() => {
// marry().then(() => {
// baby()
// })
// })
xq()
.then(marry)
.then(baby)
// xq().then(marry)
// baby()

在这里我们可以理解为老王相亲的时候疯狂对相亲对象promise,才有了后面的步入婚姻的殿堂,结婚后想生个娃也要对妻子疯狂的promise,才有了后面的小王出生了。


老王长叹了一口气,终于通过promise挽回了形象。


小结


Js异步编程方法不只这两种,还有比如事件监听,发布/订阅,生成器函数 Generator/yield等。需要我们一起去探索研究,毕竟‘学无止境’。


作者:一拾九
来源:juejin.cn/post/7225257817345884221
收起阅读 »

JS令人头疼的类型转换

web
前言 JS中的类型转换常常被人诟病,因为javascript属于弱类型语言,它对于类型的语言没有强制的限定,这对于我们来说是头疼的。不同的类型之间的运算需要先对数据的类型进行转换,在日常开发中我们经常会用到。 数据类型 基本数据类型 Number(数字) S...
继续阅读 »

前言


JS中的类型转换常常被人诟病,因为javascript属于弱类型语言,它对于类型的语言没有强制的限定,这对于我们来说是头疼的。不同的类型之间的运算需要先对数据的类型进行转换,在日常开发中我们经常会用到。


数据类型


基本数据类型



  • Number(数字)

  • String(字符串)

  • Boolean(布尔)

  • Null

  • Undefined

  • Symbol(ES6)


引用数据类型



  • object{}

  • array[]

  • function(){}

  • date()


由于JS中拥有动态类型,在定义的时候不用指定数据类型,赋值的时候可以将任意类型赋给同一个变量,例如:let a = 1; a = '1'


类型转换


什么是类型转换?


简单来说就是将值从一种数据类型转换为另一种数据类型的过程。


分为哪几种?


根据转换的特点分为:显式类型转换(强制转换)和隐式类型转换(自动转换)。


显示类型转换(强制转换)


通过Boolean()——原始值转布尔,Number()——原始值转数字,String()——原始值转字符来进行强制类型转换。这里的转换规则可以直接查看Js官方文档:Annotated ES5


1.png


2.png


我们从文档中可以知道当我们想进行强制类型转换时,js会自动会帮我们使用ToString(value),ToNumber(value)进行转换。


//原始值转布尔
console.log(Boolean('123'));
console.log(Boolean(123));
console.log(Boolean(null));
console.log(Boolean(undefined));
console.log(Boolean(true));

//原始值转数字
console.log(Number('123'));
console.log(Number(123));
console.log(Number(null));
console.log(Number(undefined));
console.log(Number(true));

//原始值转字符串
console.log(String('123'));
console.log(String(123));
console.log(String(null));
console.log(String(undefined));
console.log(String(true));

结果为:


3.png


对象转字符串,数字


通过调用特殊的对象转换方法来完成,在js中有两个方法来执行转换,这两个方法所有的对象都具备,就是用来把对象转换为原始值的。这两个方法分别为toString(),valueOf(),这两个方法对象的构造函数原型上就有,其目的就是要有办法把对象转换为原始类型。


对象转字符串


toString()方法除了Null和Undefined其他的数据类型都具有此方法。通常情况下toString()和String()效果一样。



4.png


我们在文档中重点关注对象转字符串,上图中对象转字符串有两个步骤,先是执行自带的ToPrimitive(obj,String),再返回执行结果,分以下几步:


1.判断obj是否为基本类型,是则返回


2.调用对象自带的toString方法,如果能得到一个原始类型,则返回


3.调用对象自带的valueOf方法,如果能得到一个原始类型,则返回


4.报错


对象转数字

对象转数字的话也同样是有两个步骤:先是执行自带的ToPrimitive(obj,Number),再返回执行结果,分以下几步:


1.判断obj是否为基本类型,是则返回


2.调用对象自带的valueOf方法,如果能得到一个原始类型,则返回


3.调用对象自带的toString方法,如果能得到一个原始类型,则返回


4.报错


隐式类型转换



  • 当 + 运算作为一元操作符时,会自动调用ToNumber()处理该值。(相当于Number())


例如:console.log(+'123');结果为数字123。
console.log(+[]);结果为0,因为对象[]转换为了0。



  • 当 + 运算作为二元操作符,例(a + b)


1.lprim = ToPrimitive(v1)


2.rprim = ToPrimitive(v2)


3.如果lprim是字符串或者rprim是字符串,则返回ToString(lprim)和ToStringrprim()的拼接结果


4.返回ToNumber(lprim) + ToNumber(rprim)


结语


js类型转换规则,相当于历史事件,是已经规定好的,弄清楚它,能更好地和面试官侃侃而谈。最后感谢各位的观看。


作者:一拾九
来源:juejin.cn/post/7224518612161593402
收起阅读 »

节流 你会手写吗?

web
节流 在各大面试题中,频繁出现的老油条,节流。 啥叫节流呢? 节流(throttle):每次触发定时器后,直到这个定时器结束之前无法再次触发。一般用于可预知的用户行为的优化,比如为scroll事件的回调函数添加定时器。 在间隔一段时间执行一次回调的场景有: 1...
继续阅读 »

节流


在各大面试题中,频繁出现的老油条,节流。


啥叫节流呢?


节流(throttle):每次触发定时器后,直到这个定时器结束之前无法再次触发。一般用于可预知的用户行为的优化,比如为scroll事件的回调函数添加定时器。


在间隔一段时间执行一次回调的场景有:


1.滚动加载,加载更多或滚到底部监听

2.搜索框,搜索联想功能

简单来说就是,一段时间内重复触发,按一定频率(1s、3s、5s)执行,可配置一开始就执行一次。


如果还不懂,就直接上我们的例子。我们可以看到当我们滑动屏幕的时候,会频繁运行打印这个函数。


image.png
当我们进行节流后,给它设置一个时间,那么他就只会在该时间后


image.png


上代码


其中fn代表将要运行的函数,delay代表函数触发的时间间隔。


整个代码思路,
timer=null,
flag=false, 默认刚开始不运行
设置一个定时器,
等到delay时间到了,就会开始运行这个函数fn。如果在delay之前,发生了滚动等事件,因为已经
flag = true,只会return 不会运行这个函数fn。只有等带delay到了时间,才会运行函数。


定时器实现的节流函数在第一次触发时不会执行,而是在 delay 秒之后才执行,当最后一次停止触发后,还会再执行一次函数。


js
let count = 0;
function throttle(fn, delay) {
let timer = null // 把变量放函数里面,避免全局污染
let flag = false
let that = this
return function () {
if (flag) return
flag = true
let arg = arguments // 此处为fn函数的参数
timer = setTimeout(() => {
fn.apply(that, arg)
flag = false
}, delay)
}
}
function test(a, b) {
console.log(a, b)
}
let throttleTest = throttle(test, 1000)
// 测试函数
function test1() {
console.log('普通test:', count++)
}

window.addEventListener('scroll', (e) => {
// test1() // 不用节流的话,页面滚动一直在调用
throttleTest(1, 2) // 加上节流,即使页面一直滚动,也只会每隔一秒执行一次test函数
})

作者:Mr-Wang-Y-P
来源:juejin.cn/post/7222984001769488443
收起阅读 »

上传的图片怎么满足我们的审美的呢?开始玩弄css的一些 特别属性 object-fit

web
今天开始玩弄css的一些比较冷门但是可能比较实用的属性 object-fit。 首先让我们先看看一张效果图 这两张自拍,你个人觉得哪张比较好看,不用想都知道第一张好看啦,我们肯定希望我们上传的图片都是以第一种图片当头像啊,而不是第二种扁扁的。那么这样的效果是怎...
继续阅读 »

今天开始玩弄css的一些比较冷门但是可能比较实用的属性 object-fit。


首先让我们先看看一张效果图


这两张自拍,你个人觉得哪张比较好看,不用想都知道第一张好看啦,我们肯定希望我们上传的图片都是以第一种图片当头像啊,而不是第二种扁扁的。那么这样的效果是怎么实现的呢?
image.png


诀窍 object-fit


相信大多数人都对这个属性比较陌生吧。没咋看过这个属性吧!它有啥用呢?


我来给大家介绍介绍这个属性。
object-fit是一个CSS属性,用于控制图片或视频等替换元素的尺寸和位置,以使其适合其容器。


默认情况下,替换元素的大小取决于其本身的大小,而不是其容器的大小。这可能会导致替换元素与其容器不匹配,或者在缩放容器时无法应用正确的比例。


使用object-fit属性,可以指定替换元素如何调整其大小以适应其容器。它有以下几个值:



  • fill:默认值,替换元素会拉伸以填充容器,可能会导致元素的宽高比发生变化。

  • contain:替换元素会缩放以适应容器,保持其宽高比,可能会留有空白区域。

  • cover:替换元素会缩放以填充容器,保持其宽高比,可能会被裁剪。

  • none:替换元素将保持其本来的尺寸和宽高比,可能会溢出容器。

  • scale-down:替换元素会根据容器的大小进行缩放,但不会超过其原始大小,可能会留有空白区域。


看完还是好晕,不如直接看代码和效果图



注释解释了代码中每个部分的作用:



  • object-fit: cover将图像填充到容器中,保持比例不变。

  • border-radius: 50%将图像的四个角设置为圆角,使其呈现圆形。

  • width: 340pxheight: 340px设置图像的宽度和高度。

  • border: 1px solid #ccc设置图像周围的边框。


容器1和容器2具有相同的样式,但容器1使用了object-fit属性,而容器2没有。这样,我们可以比较两者之间的区别,看看object-fit如何影响图像的呈现方式。


html
<!DOCTYPE html>
<html>

<head>
<title>object-fit示例</title>
<style>
/* 容器1样式 */
.container1 img {
object-fit: cover; /* 图像填充容器,保持比例不变 */
border-radius: 50%; /* 圆角 */
width: 340px;
height: 340px;
border: 1px solid #ccc;
}

/* 容器2样式 */
.container2 img {
border-radius: 50%; /* 圆角 */
width: 340px;
height: 340px;
border: 1px solid #ccc;
}
</style>
</head>

<body>
<h2>自拍照 object-fit</h2>
<!-- 容器1 -->
<div class="container1">
<img src="https://ts1.cn.mm.bing.net/th/id/R-C.e62783996335efecfb15e445205cc5f6?rik=2Z0xpGAe3tn1kQ&riu=http%3a%2f%2fwww.xgsy188.com%2fuploadfile%2f20131151461663843.jpg&ehk=rKGrd9FbAQUFWicdL8Omt%2bFaMw%2f09v2obcuVTAWca4w%3d&risl=&pid=ImgRaw&r=0" alt="自拍照">
</div>

<h2>自拍照2</h2>
<!-- 容器2 -->
<div class="container2">
<img src="https://ts1.cn.mm.bing.net/th/id/R-C.e62783996335efecfb15e445205cc5f6?rik=2Z0xpGAe3tn1kQ&riu=http%3a%2f%2fwww.xgsy188.com%2fuploadfile%2f20131151461663843.jpg&ehk=rKGrd9FbAQUFWicdL8Omt%2bFaMw%2f09v2obcuVTAWca4w%3d&risl=&pid=ImgRaw&r=0" alt="自拍照">
</div>
</body>

</html>


作者:Mr-Wang-Y-P
来源:juejin.cn/post/7223767530981326885
收起阅读 »

这些数组reduce的妙用,你都会吗?

web
reduce 是 JavaScript 数组对象上的一个高阶函数,它可以用来迭代数组中的所有元素,并返回一个单一的值。其常用的语法为: array.reduce(callback[, initialValue]) 其中,callback 是一个回调函数,它接...
继续阅读 »

reduce 是 JavaScript 数组对象上的一个高阶函数,它可以用来迭代数组中的所有元素,并返回一个单一的值。其常用的语法为:
array.reduce(callback[, initialValue])



其中,callback 是一个回调函数,它接受四个参数:累加器(初始值或上一次回调函数的返回值)、当前元素、当前索引、操作的数组本身。initialValue 是一个可选的初始值,如果提供了该值,则作为累加器的初始值,否则累加器的初始值为数组的第一个元素。
reduce 函数会从数组的第一个元素开始,依次对数组中的每个元素执行回调函数。回调函数的返回值将成为下一次回调函数的第一个参数(累加器)。最后,reduce 函数返回最终的累加结果。
以下是一个简单的 reduce
示例,用于计算数组中所有元素的和:


const arr = [1, 2, 3, 4, 5];
const sum = arr.reduce((accumulator, currentValue) => accumulator + currentValue);
console.log(sum); // 15

在上面的代码中,reduce 函数从数组的第一个元素开始,计算累加值,返回最终的累加结果 15。
除了数组的求和,reduce 函数还可以用于其他各种用途,如数组求平均数、最大值、最小值等。此外,reduce 函数还可以与 map、filter、forEach 等函数组合使用,实现更加复杂的数据操作。


当然,以下是一些 reduce 的实际应用案例,帮助你更好地理解它的用法:


计算数组的平均数


const arr = [1, 2, 3, 4, 5];
const average = arr.reduce((accumulator, currentValue, index, array) => {
accumulator += currentValue;
if (index === array.length - 1) {
return accumulator / array.length;
} else {
return accumulator;
}
});
console.log(average); // 3

求数组的最大值


const arr = [1, 2, 3, 4, 5];
const max = arr.reduce((accumulator, currentValue) => Math.max(accumulator, currentValue));
console.log(max); // 5

求数组的最小值


const arr = [1, 2, 3, 4, 5];
const min = arr.reduce((accumulator, currentValue) => Math.min(accumulator, currentValue));
console.log(min); // 1

数组去重


const arr = [1, 2, 3, 3, 4, 4, 5];
const uniqueArr = arr.reduce((accumulator, currentValue) => {
if (!accumulator.includes(currentValue)) {
accumulator.push(currentValue);
}
return accumulator;
}, []);
console.log(uniqueArr); // [1, 2, 3, 4, 5]

计算数组中每个元素出现的次数


const arr = [1, 2, 3, 3, 4, 4, 5];
const countMap = arr.reduce((accumulator, currentValue) => {
if (!accumulator[currentValue]) {
accumulator[currentValue] = 1;
} else {
accumulator[currentValue]++;
}
return accumulator;
}, {});
console.log(countMap); // {1: 1, 2: 1, 3: 2, 4: 2, 5: 1}

实现数组分组


const arr = [1, 2, 3, 4, 5];
const result = arr.reduce((accumulator, currentValue) => {
if (currentValue % 2 === 0) {
accumulator.even.push(currentValue);
} else {
accumulator.odd.push(currentValue);
}
return accumulator;
}, { even: [], odd: [] });
console.log(result); // {even: [2, 4], odd: [1, 3, 5]}

计算数组中连续递增数字的长度


const arr = [1, 2, 3, 5, 6, 7, 8, 9];
const result = arr.reduce((accumulator, currentValue, index, array) => {
if (index === 0 || currentValue !== array[index - 1] + 1) {
accumulator.push([currentValue]);
} else {
accumulator[accumulator.length - 1].push(currentValue);
}
return accumulator;
}, []);
const maxLength = result.reduce((accumulator, currentValue) => Math.max(accumulator, currentValue.length), 0);
console.log(maxLength); // 5

计算对象数组的属性总和


const arr = [
{ name: 'Alice', age: 25 },
{ name: 'Bob', age: 30 },
{ name: 'Charlie', age: 35 },
];
const result = arr.reduce((accumulator, currentValue) => accumulator + currentValue.age, 0);
console.log(result); // 90

将对象数组转换为键值对对象


const arr = [
{ name: 'Alice', age: 25 },
{ name: 'Bob', age: 30 },
{ name: 'Charlie', age: 35 },
];
const result = arr.reduce((accumulator, currentValue) => {
accumulator[currentValue.name] = currentValue.age;
return accumulator;
}, {});
console.log(result); // {Alice: 25, Bob: 30, Charlie: 35}

计算数组中出现次数最多的元素


const arr = [1, 2, 3, 4, 4, 4, 5, 5, 6, 6, 6, 6];
const result = arr.reduce((accumulator, currentValue) => {
accumulator[currentValue] = (accumulator[currentValue] || 0) + 1;
return accumulator;
}, {});
const maxCount = Math.max(...Object.values(result));
const mostFrequent = Object.keys(result).filter(key => result[key] === maxCount).map(Number);
console.log(mostFrequent); // [6]

实现 Promise 串行执行


const promise1 = () => Promise.resolve('one');
const promise2 = (input) => Promise.resolve(input + ' two');
const promise3 = (input) => Promise.resolve(input + ' three');

const promises = [promise1, promise2, promise3];
const result = promises.reduce((accumulator, currentValue) => {
return accumulator.then(currentValue);
}, Promise.resolve('start'));
result.then(console.log); // 'one two three'

对象属性值求和


const obj = {
a: 1,
b: 2,
c: 3
};
const result = Object.values(obj).reduce((accumulator, currentValue) => accumulator + currentValue);
console.log(result); // 6

按属性对数组分组


const arr = [
{ id: 1, name: 'John' },
{ id: 2, name: 'Mary' },
{ id: 3, name: 'Bob' },
{ id: 4, name: 'Mary' }
];
const result = arr.reduce((accumulator, currentValue) => {
const key = currentValue.name;
if (!accumulator[key]) {
accumulator[key] = [];
}
accumulator[key].push(currentValue);
return accumulator;
}, {});
console.log(result);
/*
{
John: [{ id: 1, name: 'John' }],
Mary: [
{ id: 2, name: 'Mary' },
{ id: 4, name: 'Mary' }
]
,
Bob: [{ id: 3, name: 'Bob' }]
}
*/

扁平化数组


// 如果你有一个嵌套的数组,可以使用reduce将其扁平化成一个一维数组。例如:
const nestedArray = [[1, 2], [3, 4], [5, 6]];
const flattenedArray = nestedArray.reduce((acc, curr) => acc.concat(curr), []);
console.log(flattenedArray); // [1, 2, 3, 4, 5, 6]

合并对象


// 可以使用reduce将多个对象合并成一个对象。例如:
const obj1 = { a: 1, b: 2 };
const obj2 = { c: 3, d: 4 };
const obj3 = { e: 5, f: 6 };
const mergedObj = [obj1, obj2, obj3].reduce((acc, curr) => Object.assign(acc, curr), {});
console.log(mergedObj); // {a: 1, b: 2, c: 3, d: 4, e: 5, f: 6}
复制代码
作者:思学堂
来源:juejin.cn/post/7223278436893163581
>
收起阅读 »

都这么多年了,作为一个前端的你是不是连Symbol都不会用

web
Symbol是JavaScript中的原始数据类型之一,它表示一个唯一的、不可变的值,通常用作对象属性的键值。由于Symbol值是唯一的,因此可以防止对象属性被意外地覆盖或修改。以下是Symbol的方法和属性整理: 属性 Symbol.length Symbo...
继续阅读 »

Symbol是JavaScript中的原始数据类型之一,它表示一个唯一的、不可变的值,通常用作对象属性的键值。由于Symbol值是唯一的,因此可以防止对象属性被意外地覆盖或修改。以下是Symbol的方法和属性整理:


属性


Symbol.length


Symbol构造函数的length属性值为0。


示例代码:


console.log(Symbol.length); // 0

方法


Symbol.for()


Symbol.for()方法会根据给定的字符串key,返回一个已经存在的symbol值。如果不存在,则会创建一个新的Symbol值并将其注册到全局Symbol注册表中。


示例代码:


const symbol1 = Symbol.for('foo');
const symbol2 = Symbol.for('foo');

console.log(symbol1 === symbol2); // true

使用场景: 当我们需要使用一个全局唯一的Symbol值时,可以使用Symbol.for()方法来获取或创建该值。例如,在多个模块之间共享某个Symbol值时,我们可以使用Symbol.for()来确保获取到的Symbol值是唯一的。


Symbol.keyFor()


Symbol.keyFor()方法会返回一个已经存在的Symbol值的key。如果给定的Symbol值不存在于全局Symbol注册表中,则返回undefined。


示例代码:


const symbol1 = Symbol.for('foo');
const key1 = Symbol.keyFor(symbol1);

const symbol2 = Symbol('bar');
const key2 = Symbol.keyFor(symbol2);

console.log(key1); // 'foo'
console.log(key2); // undefined

使用场景: 当我们需要获取一个全局唯一的Symbol值的key时,可以使用Symbol.keyFor()方法。但需要注意的是,只有在该Symbol值被注册到全局Symbol注册表中时,才能使用Symbol.keyFor()方法获取到其key。


Symbol()


Symbol()函数会返回一个新的、唯一的Symbol值。可以使用可选参数description来为Symbol值添加一个描述信息。


示例代码:


const symbol1 = Symbol('foo');
const symbol2 = Symbol('foo');

console.log(symbol1 === symbol2); // false

使用场景: 当我们需要使用一个唯一的Symbol值时,可以使用Symbol()函数来创建该值。通常情况下,我们会将Symbol值用作对象属性的键值,以确保该属性不会被意外地覆盖或修改。


Symbol.prototype.toString()


Symbol.prototype.toString()方法会返回Symbol值的字符串表示形式,该表示形式包含Symbol()函数创建时指定的描述信息。


示例代码:


const symbol = Symbol('foo');

console.log(symbol.toString()); // 'Symbol(foo)'

使用场景: 当我们需要将一个Symbol值转换成字符串时,可以使用Symbol.prototype.toString()方法。


Symbol.prototype.valueOf()


Symbol.prototype.valueOf()方法会返回Symbol值本身。


示例代码:


const symbol = Symbol('foo');

console.log(symbol.valueOf()); // Symbol(foo)

使用场景: 当我们需要获取一个Symbol值本身时,可以使用Symbol.prototype.valueOf()方法。


Symbol.iterator


Symbol.iterator是一个预定义好的Symbol值,表示对象的默认迭代器方法。该方法返回一个迭代器对象,可以用于遍历该对象的所有可遍历属性。


示例代码:


const obj = { a: 1, b: 2 };

for (const key of Object.keys(obj)) {
console.log(key);
}
// Output:
// 'a'
// 'b'

for (const key of Object.getOwnPropertyNames(obj)) {
console.log(key);
}
// Output:
// 'a'
// 'b'

for (const key of Object.getOwnPropertySymbols(obj)) {
console.log(key);
}
// Output:
// No output

obj[Symbol.iterator] = function* () {
for (const key of Object.keys(this)) {
yield key;
}
}

for (const key of obj) {
console.log(key);
}
// Output:
// 'a'
// 'b'

使用场景: 当我们需要自定义一个对象的迭代行为时,可以通过定义Symbol.iterator属性来实现。例如,对于自定义的数据结构,我们可以定义它的Symbol.iterator方法以便能够使用for...of语句进行遍历。


Symbol.hasInstance


Symbol.hasInstance是一个预定义好的Symbol值,用于定义对象的 instanceof 操作符行为。当一个对象的原型链中存在Symbol.hasInstance方法时,该对象可以被instanceof运算符使用。


示例代码:


class Foo {
static [Symbol.hasInstance](obj) {
return obj instanceof Array;
}
}

console.log([] instanceof Foo); // true
console.log({} instanceof Foo); // false

使用场景: 当我们需要自定义一个对象的 instanceof 行为时,可以通过定义Symbol.hasInstance方法来实现。


Symbol.isConcatSpreadable


Symbol.isConcatSpreadable是一个预定义好的Symbol值,用于定义对象在使用concat()方法时的展开行为。如果一个对象的Symbol.isConcatSpreadable属性为false,则在调用concat()方法时,该对象不会被展开。


示例代码:


const arr1 = [1, 2];
const arr2 = [3, 4];
const obj = { length: 2, 0: 5, 1: 6, [Symbol.isConcatSpreadable]: false };

console.log(arr1.concat(arr2)); // [1, 2, 3, 4]
console.log(arr1.concat(obj)); // [1, 2, { length: 2, 0: 5, 1: 6, [Symbol(Symbol.isConcatSpreadable)]: false }]

使用场景: 当我们需要自定义一个对象在使用concat()方法时的展开行为时,可以通过定义Symbol.isConcatSpreadable属性来实现。


Symbol.toPrimitive


Symbol.toPrimitive是一个预定义好的Symbol值,用于定义对象在被强制类型转换时的行为。如果一个对象定义了Symbol.toPrimitive方法,则在将该对象转换为原始值时,会调用该方法。


示例代码:


const obj = {
valueOf() {
return 1;
},
[Symbol.toPrimitive](hint) {
if (hint === 'number') {
return 2;
} else if (hint === 'string') {
return 'foo';
} else {
return 'default';
}
}
};

console.log(+obj); // 2
console.log(`${obj}`); // 'foo'
console.log(obj + ''); // 'default'


使用场景: 当我们需要自定义一个对象在被强制类型转换时的行为时,可以通过定义Symbol.toPrimitive方法来实现。


Symbol.toStringTag


Symbol.toStringTag是一个预定义好的Symbol值,用于定义对象在调用Object.prototype.toString()方法时返回的字符串。如果一个对象定义了Symbol.toStringTag属性,则在调用该对象的toString()方法时,会返回该属性对应的字符串。


示例代码:


class Foo {
get [Symbol.toStringTag]() {
return 'Bar';
}
}

console.log(Object.prototype.toString.call(new Foo())); // '[object Bar]'

使用场景: 当我们需要自定义一个对象在调用Object.prototype.toString()方法时返回的字符串时,可以通过定义Symbol.toStringTag属性来实现。


Symbol.species


Symbol.species是一个预定义好的Symbol值,用于定义派生对象的构造函数。如果一个对象定义了Symbol.species属性,则在调用该对象的派生方法(如Array.prototype.map())时,返回的新对象会使用该属性指定的构造函数。


示例代码:


class MyArray extends Array {
static get [Symbol.species]() {
return Array;
}
}

const myArr = new MyArray(1, 2, 3);
const arr = myArr.map(x => x * 2);

console.log(arr instanceof MyArray); // false
console.log(arr instanceof Array); // true

使用场景: 当我们需要自定义一个派生对象的构造函数时,可以通过定义Symbol.species属性来实现。


Symbol.match


Symbol.match是一个预定义好的Symbol值,用于定义对象在调用String.prototype.match()方法时的行为。如果一个对象定义了Symbol.match方法,则在调用该对象的match()方法时,会调用该方法进行匹配。


示例代码:


class Foo {
[Symbol.match](str) {
return str.indexOf('foo') !== -1;
}
}

console.log('foobar'.match(new Foo())); // true
console.log('barbaz'.match(new Foo())); // false

使用场景: 当我们需要自定义一个对象在调用String.prototype.match()方法时的行为时,可以通过定义Symbol.match方法来实现。


Symbol.replace


Symbol.replace是一个预定义好的Symbol值,用于定义对象在调用String.prototype.replace()方法时的行为。如果一个对象定义了Symbol.replace方法,则在调用该对象的replace()方法时,会调用该方法进行替换。


示例代码:


class Foo {
[Symbol.replace](str, replacement) {
return str.replace('foo', replacement);
}
}

console.log('foobar'.replace(new Foo(), 'baz')); // 'bazbar'
console.log('barbaz'.replace(new Foo(), 'baz')); // 'barbaz'

使用场景: 当我们需要自定义一个对象在调用String.prototype.replace()方法时的行为时,可以通过定义Symbol.replace方法来实现。


Symbol.search


Symbol.search是一个预定义好的Symbol值,用于定义对象在调用String.prototype.search()方法时的行为。如果一个对象定义了Symbol.search


class Foo {
[Symbol.search](str) {
return str.indexOf('foo');
}
}

console.log('foobar'.search(new Foo())); // 0
console.log('barbaz'.search(new Foo())); // -1


使用场景: 当我们需要自定义一个对象在调用String.prototype.search()方法时的行为时,可以通过定义Symbol.search方法来实现。


Symbol.split


Symbol.split是一个预定义好的Symbol值,用于定义对象在调用String.prototype.split()方法时的行为。如果一个对象定义了Symbol.split方法,则在调用该对象的split()方法时,会调用该方法进行分割。


示例代码:


class Foo {
[Symbol.split](str) {
return str.split(' ');
}
}

console.log('foo bar baz'.split(new Foo())); // ['foo', 'bar', 'baz']
console.log('foobarbaz'.split(new Foo())); // ['foobarbaz']

使用场景: 当我们需要自定义一个对象在调用String.prototype.split()方法时的行为时,可以通过定义Symbol.split方法来实现。


Symbol.iterator


Symbol.iterator是一个预定义好的Symbol值,用于定义对象在被遍历时的行为。如果一个对象定义了Symbol.iterator方法,则可以使用for...of循环、扩展运算符等方式来遍历该对象。


示例代码:


class Foo {
constructor() {
this.items = ['foo', 'bar', 'baz'];
}

*[Symbol.iterator]() {
for (const item of this.items) {
yield item;
}
}
}

const foo = new Foo();

for (const item of foo) {
console.log(item);
}

// 'foo'
// 'bar'
// 'baz'

使用场景: 当我们需要自定义一个对象在被遍历时的行为时,可以通过定义Symbol.iterator方法来实现。比如,我们可以通过实现Symbol.iterator方法来支持自定义数据结构的遍历。


Symbol.toPrimitive


Symbol.toPrimitive是一个预定义好的Symbol值,用于定义对象在被强制类型转换时的行为。如果一个对象定义了Symbol.toPrimitive方法,则可以通过调用该方法来进行强制类型转换。


示例代码:


const obj = {
valueOf() {
return 1;
},
[Symbol.toPrimitive](hint) {
if (hint === 'default') {
return 'default';
} else if (hint === 'number') {
return 2;
} else {
return 'foo';
}
}
};

console.log(+obj); // 2
console.log(`${obj}`); // 'foo'
console.log(obj + ''); // 'default'

使用场景: 当我们需要自定义一个对象在被强制类型转换时的行为时,可以通过定义Symbol.toPrimitive方法来实现。


Symbol.toStringTag


Symbol.toStringTag是一个预定义好的Symbol值,用于定义对象在调用Object.prototype.toString()方法时返回的字符串。如果一个对象定义了Symbol.toStringTag属性,则在调用该对象的toString()方法时,会返回该属性对应的字符串。


示例代码:


class Foo {
get [Symbol.toStringTag]() {
return 'Bar';
}
}

console.log(Object.prototype.toString.call(new Foo())); // '[object Bar]'

使用场景: 当我们需要自定义一个对象在调用Object.prototype.toString()方法时返回的字符串时,可以通过定义Symbol.toStringTag属性来实现。这样做有助于我们更清晰地表示对象的类型。


Symbol.unscopables


Symbol.unscopables是一个预定义好的Symbol值,用于定义对象在使用with语句时的行为。如果一个对象定义了Symbol.unscopables属性,则在使用with语句时,该对象的指定属性将不会被绑定到with语句的环境中。


示例代码:


const obj = {
a: 1,
b: 2,
c: 3,
[Symbol.unscopables]: {
c: true
}
};

with (obj) {
console.log(a); // 1
console.log(b); // 2
console.log(c); // ReferenceError: c is not defined
}

使用场景: 由于with语句会带来一些安全性问题和性能问题,因此在实际开发中不建议使用。但是,如果确实需要使用with语句,可以通过定义Symbol.unscopables属性来避免某些属性被误绑定到with语句的环境中。


Symbol.hasInstance


Symbol.hasInstance是一个预定义好的Symbol值,用于定义对象在调用instanceof运算符时的行为。如果一个对象定义了Symbol.hasInstance方法,则在调用该对象的instanceof运算符时,会调用该方法来判断目标对象是否为该对象的实例。


示例代码:


class Foo {
static [Symbol.hasInstance](obj) {
return Array.isArray(obj);
}
}

console.log([] instanceof Foo); // true
console.log({} instanceof Foo); // false

使用场景: 当我们需要自定义一个对象在调用instanceof运算符时的行为时,可以通过定义Symbol.hasInstance方法来实现。比如,我们可以通过实现Symbol.hasInstance方法来支持自定义数据类型的判断。


总结


Symbol是ES6中新增的一种基本数据类型,用于表示独一无二的值。Symbol值在语言层面上解决了属性名冲突的问题,可以作为对象的属性名使用,并且不会被意外覆盖。除此之外,Symbol还具有以下特点:



  • Symbol值是唯一的,每个Symbol值都是独一无二的,即使是通过相同的描述字符串创建的Symbol值,也不会相等;

  • Symbol值可以作为对象的属性名使用,并且不会被意外覆盖;

  • Symbol值可以作为私有属性来使用,因为无法通过对象外部访问对象中的Symbol属性;

  • Symbol值可以被用作常量,因为它们是唯一的;

  • Symbol值可以用于定义迭代器、类型转换规则、私有属性、元编程等高级功能。


在使用Symbol时需要注意以下几点:



  • Symbol值不能使用new运算符创建;

  • Symbol值可以通过描述字符串来创建,但是描述字符串并不是Symbol值的唯一标识符;

  • Symbol属性在使用时需要用[]来访问,不能使用.运算符;

  • 同一对象中的多个Symbol属性是独立的,它们之间不会互相影响。


总之,Symbol是一个非常有用的数据类型,在JavaScript中具有非常广泛的应用。使用Symbol可以有效地避免属性名冲突问题,并且可以为对象提供一些高级功能。熟练掌握Symbol,有助于我们写出更加健壮、高效和可维护的Jav

作者:布衣1983
来源:juejin.cn/post/7226193000496463928
aScript代码。

收起阅读 »

实现tabs圆角及反圆角效果

web
直接上最终效果 基本页面结构 <div class="tab-list"> <div v-for="tab in tabList" :key="tab.id" ...
继续阅读 »

直接上最终效果


image.png


image.png


基本页面结构


      <div class="tab-list">
<div
v-for="tab in tabList"
:key="tab.id"
class="tab-item"
:class="activeTab === tab.id ? 'tab-selected' : ''"
@click="onTab(tab.id)"
>

<image :src="tab.icon" class="tab-icon" />
<div>{{ tab.label }}</div>
</div>
</div>

  $tab-height: 52px;
$tab-bgcolor: #e2e8f8

.tab-list {
display: flex;
border-radius: 12px 12px 0 0;
background-color: $tab-bgcolor;

.tab-item {
flex: 1;
height: $tab-height;
display: flex;
justify-content: center;
align-items: center;
font-size: 15px;
opacity: 0.65;
color: $primary-color;
font-weight: 600;
position: relative;
}

.tab-icon {
width: 17px;
height: 17px;
margin-right: 4px;
}

.tab-selected {
opacity: 1;
background: #ffffff;
}

}


image.png


image.png


添加上半两个圆角


这个很简单


    .tab-selected {
opacity: 1;
background: #ffffff;
// 新增
border-radius: 12px 12px 0 0;
}

image.png


添加下半两个反圆角


加两个辅助的伪元素


    .tab-selected::before {
content: '';
position: absolute;
left: -12px;
bottom: 0;
width: 12px;
height: $tab-height;
background: red;
border-radius: 0 0 12px 0;
}
.tab-selected::after {
content: '';
position: absolute;
right: -12px;
bottom: 0;
width: 12px;
height: $tab-height;
background: red;
border-radius: 0 0 0 12px;
}

image.png


image.png


再添加box-shadow


    .tab-selected {
opacity: 1;
background: #ffffff;
border-radius: 12px 12px 0 0;
// 新装置
box-shadow: 12px 12px 0 0 blue, -12px 12px 0 0 blue;
}

image.png


image.png


到这个就差不多可以收尾了,把伪元素的背景色改为tabs的背景色


    .tab-selected::before {
content: '';
position: absolute;
left: -12px;
bottom: 0;
width: 12px;
height: $tab-height;
background: #e2e8f8; // 修改
border-radius: 0 0 12px 0;
}
.tab-selected::after {
content: '';
position: absolute;
right: -12px;
bottom: 0;
width: 12px;
height: $tab-height;
background: #e2e8f8; // 修改
border-radius: 0 0 0 12px;
}

image.png


再处理下box-shadow


    .tab-selected {
opacity: 1;
background: #ffffff;
border-radius: 12px 12px 0 0;
// box-shadow: 12px 12px 0 0 blue, -12px 12px 0 0 blue;
box-shadow: 12px 12px 0 0 #ffffff, -12px 12px 0 0 #ffffff;
}

完美


image.png


但是两边的还会有问题


image.png


image.png


父级元素overflow:hidden即可


.tab-list {
display: flex;
position: relative;
z-index: 2;
border-radius: 12px 12px 0 0;
background-color: #e2e8f8;
overflow: hidden; // 新增
}

收工


参考



CSS3 实现双圆角 Tab 菜单



相关知识点回顾


box-shadow




  1. x轴偏移 右为正

  2. y轴偏移 下为正

  3. 模糊半径

  4. 阴影大小

  5. 颜色

  6. 位置 inset



border-radius


先记得下面这个图


image.png



  • 一个值的时候设置1/2/3/4

  • 两个值的时候设置 1/32/4

  • 三个值的时候设置12/4, 3

  • 四个值就简单了1234


border-radius 如果需要设置某个角的圆角边框,可以使用下面四个



  1. border-top-left-radius;

  2. border-top-right-radius;

  3. border-bottom-left-radius;

  4. border-bottom-right-radius;


又要画一个图了,上面四个属性,又可以设置一个值或者两个值


第一个值是水平半径,第二个是垂直半径。如果省略第二个值,它是从第一个复制


image.png


image.png


当然border-radius也可以分别设置水平半径 垂直半径



border-radius: 10px / 20px 30px 40px 50px; 水平半径都为10px, 但四个角的垂直半径分别设置



image.png



border-radius: 50px 10px / 20px;



image.png


下期预告


曲线圆角tabs


image.png


传送门


作者:feng_cc
来源:juejin.cn/post/7224311569777934392
收起阅读 »

被问了无数次的函数防抖与函数节流,这次你应该学会了吧

web
前言 本篇文章内容,或许早已是烂大街的解读文章。不过参加几场面试下来发现,不少伙伴们还是似懂非懂地栽倒在(~面试官~)深意的笑容之下,权当温故知新吧。 文章从防抖、节流的原理说起再结合实际开发的场景,分别逐步实现完整的防抖和节流函数。 函数防抖 原理:当持续...
继续阅读 »

前言


本篇文章内容,或许早已是烂大街的解读文章。不过参加几场面试下来发现,不少伙伴们还是似懂非懂地栽倒在(~面试官~)深意的笑容之下,权当温故知新吧。


文章从防抖、节流的原理说起再结合实际开发的场景,分别逐步实现完整的防抖和节流函数。


函数防抖



  • 原理:当持续触发一个事件时,在n秒内,事件没有再次触发,此时才会执行回调;如果n秒内,又触发了事件,就重新计时

  • 适用场景:



    • search远程搜索框:防止用户不断输入过程中,不断请求资源,n秒内只发送1次,用防抖来节约资源

    • 按钮提交场景,比如点赞,表单提交等,防止多次提交

    • 监听resize触发时, 不断的调整浏览器窗口大小会不断触发resize,使用防抖可以让其只执行一次



  • 辅助理解:在你坐电梯时,当一直有人进电梯(连续触发),电梯门不会关闭,在一定时间间隔内没有人进入(停止连续触发)才会关闭。


下面我们先实现一个简单的防抖函数,请看栗子:


// 简单防抖函数
const debounce = (fn, delay) => {
  let timer;
  return function () {
    const context = this;
    const args = arguments;
    clearTimeout(timer);

    timer = setTimeout(function () {
      fn.call(context, ...args);
      //等同于上一句 fn.apply(context, args)
    }, delay);
  };
};

// 请求接口方法
const ajax = (e) => {
  console.log(`send ajax ${new Date()} ${e.target.value}`);
};

// 绑定监听事件
const noneDebounce = document.getElementsByClassName("none_debounce")[0];
const debounceInput = document.getElementsByClassName("debounce")[0];

noneDebounce.addEventListener("keyup", ajax);
debounceInput.addEventListener("keyup"debounce(ajax, 500));

运行效果如下:图片


点击这里,试试效果点击demo


可以很清晰的看到,当我们频繁输入时, 不使用节流就会不断的发送数据请求,但是使用节流后,只有当你在指定间隔时间内没有输入,才会执行发送数据请求的函数。


上面有个注意点:



  • this指向问题,在定时器中如果使用箭头函数()=>{fn.call(this, ...args)} 与上面代码效果一样, 原因时箭头函数的this是**「继承父执行上下文里面的this」**


关于防抖函数的疑问:



  1. 为什么要使用 fn.apply(context, args), 而不是直接调用 fn(args)


如果我们不使用防抖函数debounce时, 在ajax函数中打印this的值为dom节点:


<input class="debounce" type="text">

在使用debounce函数后,如果我们不使用fn.apply(context, args)修改this的指向, this就会指向window(ES6下为undefined)



  1. 为什么要传入arguments参数


我们同样与未使用防抖函数的场景进行对比


const ajax = (e) =>{
    console.log(e)
}


  1. 怎么给ajax函数传参


有的小伙伴就说了, 你的ajax只能接受绑定事件的参数,不是我想要的,我还要传入其他参数,so easy!


const sendAjax = debounce(ajax, 1000)
sendAjax(参数1, 参数2,...)

因为sendAjax 其实就是debounce中return的函数, 所以你传入什么参数,最后都给了fn


在未使用时,调用ajax函数对打印一个KeyboardEvent对象


image.png


使用debounce函数时,如果不传入arguments, ajax中的参数打印为undefined,所以我们需要将接收到的参数,传递给fn


函数防抖的理解:




我个人的理解其实和平时上电梯的原理一样:当一直有人进电梯时(连续触发),电梯门不会关闭,在一定时间间隔内没有人进入(停止连续触发)才会关闭。




从上面的例子,对防抖有了初步的认识,但是在实际开发中,需求往往要更加的复杂,比如我们要提交一个表单按钮,为了防止用户多次提交表单,可以使用节流, 但如果使用上面的节流,就会导致用户停止连续点击才会提交,而我们希望让用户点击时,立即提交, 等到n秒后,才可以重新提交。


对上面的代码进行改造,得到立即提交版:


const debounce = (fn, delay, immediate) => {
  let timer;
  return function () {
    const context = this;
    const args = arguments;
    clearTimeout(timer);

    if (immediate) {
      let startNow = !timer;

      timer = setTimeout(function () {
        timer = null;
      }, delay);

      if (startNow) {
        fn.apply(context, args);
      }
    } else {
      timer = setTimeout(function () {
        fn.call(context, ...args);
        //等同于上一句 fn.apply(context, args)
      }, delay);
    }
  };
};

从上面的代码可以看到,通过immediate 参数判断是否是立刻执行。


timer = setTimeout(function () {
    timer = null
}, delay)

立即执行的逻辑中,如果去掉上面这小段代码, 也是立即执行,但是之后就不会再执行提交了,当我们提交失败了怎么办(哭),所以加上上面这段代码,在设定的时间间隔内,将timer设置为null, 过了设定的时间间隔,可以再次触发提交按钮的立即执行,这才是完整的。


这是一个使用立即提交版本的防抖实现的了一个提交按钮demo


目前我们已经实现了包含非立即执行立即执行功能的防抖函数,感兴趣的小伙伴可以和我一起继续探究一下去,完善防抖函数~




做直播功能时,产品的小伙伴给提出这样一个需求:


直播的小窗口可以拖动, 点击小窗口以及拖动时, 显示关闭小窗口按钮,当拖动结束2s后, 隐藏关闭按钮;当点击关闭按钮时, 关闭小窗口




分析需求, 我们可以使用防抖来实现, 用户连续拖动小窗口过程中, 不执行隐藏关闭按钮,拖动结束后2s才执行隐藏关闭按钮;但是点击关闭按钮后,我们希望可以取消防抖, 所以需要继续完善防抖函数, 使其可以被取消。


「可取消版本」


const debounce = (fn, delay, immediate) => {
  let timer, debounced;
  // 修改--
  debounced = function () {
    const context = this;
    const args = arguments;
    clearTimeout(timer);

    if (immediate) {
      let startNow = !timer;

      timer = setTimeout(function () {
        timer = null;
      }, delay);

      if (startNow) {
        fn.apply(context, args);
      }
    } else {
      timer = setTimeout(function () {
        fn.call(context, ...args);
      }, delay);
    }
  };

  // 新增--
  debounced.cancel = function () {
    clearTimeout(timer);
    timer = null;
  };
  return debounced;
};

从上面代码可以看到,修改的地方是将return的函数赋值给debounced对象, 并且给debounced扩展了一个cancel方法, 内部执行了清除定时器timer, 并且将其设置为null; 为什么要将timer设置为null呢? 由于debounce内部形成了闭包, 避免造成内存泄露


上面的需求我写了个小demo, 需要的小伙伴可以看看可取消版本demo, 效果如下所示:图片


这个demo中,在拖拽过程中还可以使用节流,减少页面重新计算位置的次数,在下边学完节流,大家不妨试试


介绍节流原理、区别以及应用


前面学习了防抖,也知道了我们为什么要使用防抖来限制事件触发频率,那我们接下来学习另一种限制的方式节流(throttle)


函数节流



  • 原理:当频繁的触发一个事件,每隔一段时间, 只会执行一次事件。

  • 适用场景:



    • 拖拽场景:固定时间内只执行一次, 防止高频率的的触发位置变动

    • 监听滚动事件:实现触底加载更多功能

    • 屏幕尺寸变化时, 页面内容随之变动,执行相应的逻辑

    • 射击游戏中的mousedown、keydown时间



  • 辅助理解:


下面我们就来实现一个简单的节流函数,由于每隔一段时间执行一次,那么就需要计算时间差,我们有两种方式来计算时间差:一种是使用时间戳,另一种是设置定时器


使用时间戳实现


function throttle(func, delay) {
  let args;
  let lastTime = 0;

  return function () {
    // 获取当前时间
    const currentTime = new Date().getTime();
    args = arguments;
    if (currentTime - lastTime > delay) {
      func.apply(this, args);
      lastTime = currentTime;
    }
  };
}

使用时间搓的方式来实现的思路比较简单,当触发事件时,获取当前时间戳,然后减去之前的时间戳(第一次设置为0), 如果差值大于设置的等待时间, 就执行函数,然后更新上一次执行时间为为当前的时间戳,如果小于设置的等待时间,就不执行。


使用定时器实现


下面我们来看使用定时器实现的方式:与时间戳实现的思路是有差别的, 我们在事件触发时设置一个定时器, 当再次触发事件时, 如果定时器存在,就不执行;等过了设置的等待时间,定时器执行,我们需要在定时器执行时,清空定时器,这样就可以设置下一个定时器了


function throttle1(fn, delay) {
  let timer;
  return function () {
    const context = this;
    let args = arguments;

    if (timer) return;
    timer = setTimeout(function () {
      console.log("hahahhah");
      fn.apply(context, args);

      clearTimeout(timer);
      timer = null;
    }, delay);
  };
}

虽然两种方式都实现了节流, 但是他们达到的效果还是有一点点差别的,第一种实现方式,事件触发时,会立即执行函数,之后每隔指定时间执行,最后一次触发事件,事件函数不一定会执行;假设你将等待时间设置为1s, 当3.2s时停止事件的触发,那么函数只会被执行3次,以后不会再执行。


第二种实现方式,事件触发时,函数不会立即执行, 需要等待指定时间后执行,最后一次事件触发会被执行;同样假设等待时间设置为1s, 在3.2秒是停止事件的触发,但是依然会在第4秒时执行事件函数


总结


对两种实现方式比较得出:



  1. 第一种方式, 事件会立即执行, 第二种方式事件会在n秒后第一次执行

  2. 第一种方式,事件停止触发后,就不会在执行事件函数, 第二种方式停止触发后仍然会再执行一次


接下来我们写一个下拉加载更多的小demo来验证上面两个节流函数:点击查看代码


let state = 0 // 0: 加载已完成  1:加载中  2:没有更多
let page = 1
let list =[{...},{...},{...}]

window.addEventListener('scroll'throttle(scrollEvent, 1000))

function scrollEvent() {
    // 当前窗口高度
    let winHeight =
        document.documentElement.clientHeight || document.body.clientHeight

    // 滚动条滚动的距离
    let scrollTop = Math.max(
        document.body.scrollTop,
        document.documentElement.scrollTop
    )

    // 当前文档高度
    let docHeight = Math.max(
        document.body.scrollHeight,
        document.documentElement.scrollHeight
    )
    console.log('执行滚动')

    if (scrollTop + winHeight >= docHeight - 50) {
        console.log('滚动到底部了!')
        if (state == 1 || state == 2) {
            return
        }
        getMoreList()
    }
}

function getMoreList() {
    state = 1
    tipText.innerHTML = '加载数据中'
    setTimeout(() => {
        renderList()
        page++

        if (page > 5) {
            state = 2
            tipText.innerHTML = '没有更多数据了'
            return
        }
        state = 0
        tipText.innerHTML = ''
    }, 2000)
}

function renderList() {
    // 渲染元素
    ...
}

使用第一种方式效果如下:图片


一开始滚动便会触发滚动事件, 但是在滚动到底部时停止, 不会打印"滚动到底部了"; 这就是由于事件停止触发后,就不会在执行事件函数


使用第二种方式, 为了看到效果,将事件设置为3s, 这样更能直观感受到事件函数是否立即执行:


// window.addEventListener('scroll', throttle(scrollEvent, 1000))
window.addEventListener('scroll'throttle1(scrollEvent, 3000))

图片


一开始滚动事件函数并不会被触发,而是等到3s后才触发;而当我们快速的滚动到底部后停止滚动事件, 最后还是会执行一次


上面的这个例子是为了辅助理解这两种实现不方式的不同。


时间戳 + 定时器实现版本


在实际开发中, 上面两种实现方案都不满足我们的需求,我们希望一开始滚动就立即执行,停止触发的时候也还能执行一次。结合时间搓方式和定时器方式实现如下:


function throttle(fn, delay) {
  let timer, context, args;
  let lastTime = 0;

  return function () {
    context = this;
    args = arguments;

    let currentTime = new Date().getTime();

    if (currentTime - lastTime > delay) {
      // 防止时间戳和定时器重复
      // -----------
      if (timer) {
        clearTimeout(timer);
        timer = null;
      }
      // -----------
      fn.apply(context, args);
      lastTime = currentTime;
    }
    if (!timer) {
      timer = setTimeout(() => {
        // 更新执行时间, 防止重复执行
        // -----------
        lastTime = new Date().getTime();
        // -----------
        fn.apply(context, args);
        clearTimeout(timer);
        timer = null;
      }, delay);
    }
  };
}

使用演示效果如下:


图片


实现思路是结合两种实现方式,同时避免两种方式重复执行, 所以当调用时间戳执行函数时,需要将定时器清空;当使用到定时器执行函数时,需要增加修改执行记录的时间lastTime


我们可以看到,开始滚动立即会打印页面滚动了,停止滚动后,时间会再执行一次,滚动到底部时停止,也会执行到滚动到底部了


最终完善版


上面的节流函数满足了我们的基本需求, 但是我们可以进一步对节流函数进行优化,使得节流函数可以满足下面三种情况:



  • 事件函数立即执行,并且事件停止后再执行一次(以满足)

  • 事件函数立即执行,但是事件停止后不再执行(待探究)

  • 事件函数不立即执行,但是事件停止后再执行一次(待探究)




注意点:事件函数不立即执行,事件停止不再执行一次 这种情况不能满足,在后面从代码角度会做分析。




我们设置两个参数startlast分别控制是否立即执行与最后是否执行;修改上一版代码, 实现如下:


function throttle(fn, delay, option = {}) {
  let timer, context, args;
  let lastTime = 0;

  return function () {
    context = this;
    args = arguments;

    let currentTime = new Date().getTime();

    // 增加是否立即执行判断
    if (option.start == false && !lastTime) lastTime = currentTime;

    if (currentTime - lastTime > delay) {
      if (timer) {
        clearTimeout(timer);
        timer = null;
      }
      fn.apply(context, args);
      lastTime = currentTime;
    }
    // 增加最后是否再执行一次判断
    if (!timer && option.last == true) {
      timer = setTimeout(() => {
        // 确保再次触发事件时, 仍然不立即执行
        lastTime = option.start == false ? 0 : new Date().getTime();
        fn.apply(context, args);
        clearTimeout(timer);
        timer = null;
      }, delay);
    }
  };
}

上面代码就修改了三个地方,一个是立即执行之前增加一个判断:


if (option.start == false && !lastTime) lastTime = currentTime

如果传入参数是非立即执行, 并且lastTime为0, 将当前时间戳赋值给lastTime, 这样就不会进入 if (currentTime - lastTime > delay)


第二个修改地方, 增加最后一次是否执行的判断:


// 原来
// if (!timer) {...}

// 修改后
if (!timer && option.last == true) {
   ...
}

当传入last为true时,才使用定时器计时方式, 反之通过时间戳实现逻辑即可满足


第三个修改的地方, 也是容易被忽视的点, 如果start传入false,last传入true(即不立即执行,但最后还会执行一次), 需要在执行定时器逻辑调用事件函数时, 将lastTime设置为0:


 // 确保再次触发事件时, 仍然不立即执行
lastTime = option.start ==false0 : new Date().getTime()

这里解决的是再次触发事件时, 也能保证不立即执行。


疑问点


相信有的小伙伴会存在疑问,为什么没有讨论不立即执行, 最后一次也不执行的情况呢(即 start为true, last为true), 因为这种情况满足不了。


当最后一次不执行, 也就不会进入到 定时器执行逻辑,也就无法对 lastTime重置为0,所以,当再一次触发事件时,就会立即执行,与我们的需求矛盾了。关于这一点,大家了解即可了。


到这里,我们的节流函数功能就差不多了, 如果有兴趣的小伙伴可以自己实现一下可取消功能, 与防抖函数实现方式一致, 这里就不赘述了。


作者:白哥学前端
来源:juejin.cn/post/7230419964300951613
收起阅读 »

跳舞的小人,鼠标跟随事件

web
鼠标跟随事件 在这里,我本来想弄一个灰太狼抓羊的动画效果,就是将我们的鼠标logo替换成一只羊的照片,然后后面跟随着一只狼,设置了cursor: url('./01.gif'), auto这个属性,但是好像没有成功,好像是兼容问题。于是找了一张给会动的gif。...
继续阅读 »

鼠标跟随事件


在这里,我本来想弄一个灰太狼抓羊的动画效果,就是将我们的鼠标logo替换成一只羊的照片,然后后面跟随着一只狼,设置了cursor: url('./01.gif'), auto这个属性,但是好像没有成功,好像是兼容问题。于是找了一张给会动的gif。


实现效果


整体十分简单,主要就是js代码。


01.gif
html里我们就只是放了一张图片


<div class="img"></div>

然后简简单单的给他们设置了一下大小和样式。


  * {
margin: 0;
padding: 0;
}

![image.png](https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/e17598cd683f41fe89fddda68981de97~tplv-k3u1fbpfcp-watermark.image?)
body {
background: rgb(240, 230, 240);
}

.img {
width: 10%;
height: 20%;
position: absolute;
background-image: url('./01.gif');
background-size: cover;
}

看一看主要的js代码


这里我们主要是进行一些基本属性的定义和设置,index可以看成是时间桢或者循环次数。


let img = document.querySelector('.img')
// 定义小图片的旋转角度
let deg = 0
// 定义小图片位于网页左侧的位置
let imgx = 0
// 定义小图片位于网页顶部的位置
let imgy = 0
// 定义小图片x轴的位置
let imgl = 0
// 定义小图片y轴的位置
let imgt = 0
// 定义小图片翻转的角度
let y = 0
// 定义一个计数器
let index = 0

这段代码的作用是根据鼠标在图片上的位置计算图片的旋转角度和翻转。


首先,通过 e.x 获取鼠标在页面上的横坐标,img.offsetLeft 获取图片左边边缘距页面左边边缘的距离,img.clientWidth / 2 获取图片宽度的一半,即图片中心点距图片左边边缘的距离。将这三个值相减,得到鼠标相对于图片中心点的横向偏移量,即 imgx


 imgx = e.x - img.offsetLeft - img.clientWidth / 2

同样地,通过 e.y 获取鼠标在页面上的纵坐标,img.offsetTop 获取图片上边边缘距页面上边边缘的距离,img.clientHeight / 2 获取图片高度的一半,即图片中心点距图片上边边缘的距离。将这三个值相减,得到鼠标相对于图片中心点的纵向偏移量,即 imgy


imgy = e.y - img.offsetTop - img.clientHeight / 2

接下来,根据 imgximgy 的值,使用 Math.atan2 计算出以图片中心为原点的弧度值,并将弧度值转换为角度值,即 deg,这就是图片需要旋转的角度。
最后,将 deg 赋值给 rotate 属性,就可以实现对图片的旋转了。


 deg = 360 * Math.atan(imgy / imgx) / (2 * Math.PI)

然后,通过 index = 0 定义了一个初始值为 0 的变量 index,用于后续的操作。接下来,通过 let x = event.clientX 获取到当前鼠标的水平坐标位置。


    // 每当鼠标移动的时候重置index
index = 0
// 定义当前鼠标的位置
let x = event.clientX

然后,使用 if 判断图片的左边界是否小于当前鼠标的位置,也就是判断鼠标是否在图片的右侧。如果鼠标在图片的右侧,说明图片需要向左翻转,这时候将 y 赋值为 -180,用于后续的样式设置。如果鼠标在图片的左侧,说明图片无需翻转,此时将 y 赋值为 0。最终,将 y 值赋给图片的 rotateY 样式属性,就可以实现对图片的翻转效果了。当 y-180 时,图片将被翻转过来;当 y0 时,图片不会被翻转。


 // 当鼠标的x轴大于图片的时候,就要对着鼠标,所以需要将图片翻转过来
// 否则就不用翻转
if (img.offsetLeft < x) {
y = -180
} else {
y = 0
}


 window.addEventListener('mousemove', function (e) {
// 获取网页左侧距离的图片位置
imgx = e.x - img.offsetLeft - img.clientWidth / 2
// 多去网页顶部距离图片的位置
imgy = e.y - img.offsetTop - img.clientHeight / 2
// 套入公式,定义图片的旋转角度
deg = 360 * Math.atan(imgy / imgx) / (2 * Math.PI)
// 每当鼠标移动的时候重置index
index = 0
// 定义当前鼠标的位置
let x = event.clientX
// 当鼠标的x轴大于图片的时候,就要对着鼠标,所以需要将图片翻转过来
// 否则就不用翻转
if (img.offsetLeft < x) {
y = -180
} else {
y = 0
}
})

接下来就要实现图片跟随了


这段代码的作用是通过 JavaScript 实现对图片的旋转和移动。然后利用了setInterval一直重复


首先,使用 img.style.transform 将旋转角度 deg 和翻转角度 y 应用于元素的 transform 样式。rotateZ 用于实现元素绕 z 轴旋转,而 rotateY 则用于实现元素的翻转效果。注意,这里使用字符串拼接的方式将旋转角度和翻转角度拼接起来,以达到应用两个属性值的效果。


img.style.transform = "rotateZ(" + deg + "deg) rotateY(" + y + "deg)"

接下来,将 index 的值加一,即 index++,表明下一帧需要进行的操作。


index++

然后,使用条件语句 if (index < 50) 对小图片的位置进行调整。在这里,通过不停地调整小图片的位置,实现了小图片沿着鼠标运动的效果。其中,imgl += imgx / 50 用于计算小图片应移动的水平距离,而 imgt += imgy / 50 则用于计算小图片应移动的垂直距离。50 是移动的帧数,可以根据需求进行调整。


// 在这里设置小图片的位置和速度,并判断小图片到达鼠标位置时停止移动 
if (index < 100)
{
imgl += imgx / 100
imgt += imgy / 100
}
img.style.left = imgl + "px"
img.style.top = imgt + "px"

setInterval(() => {
// 设置小图片的旋转和翻转
img.style.transform = "rotateZ(" + deg + "deg) rotateY(" + y + "deg)"
index++
// 在这里设置小图片的位置和速度,并判断小图片到达鼠标位置时停止移动
if (index < 100) {
imgl += imgx / 100
imgt += imgy / 100
}
img.style.left = imgl + "px"
img.style.top = imgt + "px"
}, 10)

源码


<!DOCTYPE html>
<html lang="en">

<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>鼠标跟随</title>
<style>
* {
margin: 0;
padding: 0;
}

body {
background: rgb(240, 230, 240);
}

.img {
width: 10%;
height: 20%;
position: absolute;
background-image: url('./01.gif');
background-size: cover;
}
</style>
</head>

<body>
<div class="img"></div>
</body>
<script>
let img = document.querySelector('.img')
// 定义小图片的旋转角度
let deg = 0
// 定义小图片位于网页左侧的位置
let imgx = 0
// 定义小图片位于网页顶部的位置
let imgy = 0
// 定义小图片x轴的位置
let imgl = 0
// 定义小图片y轴的位置
let imgt = 0
// 定义小图片翻转的角度
let y = 0
// 定义一个计数器
let index = 0

window.addEventListener('mousemove', function (e) {
// 获取网页左侧距离的图片位置
imgx = e.x - img.offsetLeft - img.clientWidth / 2
// 多去网页顶部距离图片的位置
imgy = e.y - img.offsetTop - img.clientHeight / 2
// 套入公式,定义图片的旋转角度
deg = 360 * Math.atan(imgy / imgx) / (2 * Math.PI)
// 每当鼠标移动的时候重置index
index = 0
// 定义当前鼠标的位置
let x = event.clientX
// 当鼠标的x轴大于图片的时候,就要对着鼠标,所以需要将图片翻转过来
// 否则就不用翻转
if (img.offsetLeft < x) {
y = -180
} else {
y = 0
}
})
setInterval(() => {
// 设置小图片的旋转和翻转
img.style.transform = "rotateZ(" + deg + "deg) rotateY(" + y + "deg)"
index++
// 在这里设置小图片的位置和速度,并判断小图片到达鼠标位置时停止移动
if (index < 100) {
imgl += imgx / 100
imgt += imgy / 100
}
img.style.left = imgl + "px"
img.style.top = imgt + "px"
}, 10)
</script>

</html>

作者:Mr-Wang-Y-P
来源:juejin.cn/post/7230457833212280893
收起阅读 »

React 你是真的骚啊,一个组件就有这么多个设计模式🙄🙄🙄

web
React 真的是太灵活了,写它就感觉像是在写原生 JavaScript 一样,一个功能你可以有多种实现方式,例如你要实现动态样式,只要你愿意去做,你会有很多种解决方案,这可能也就是 React 会比 Vue 相对来说比较难一点的原因,这或许也就是这么喜欢 R...
继续阅读 »

React 真的是太灵活了,写它就感觉像是在写原生 JavaScript 一样,一个功能你可以有多种实现方式,例如你要实现动态样式,只要你愿意去做,你会有很多种解决方案,这可能也就是 React 会比 Vue 相对来说比较难一点的原因,这或许也就是这么喜欢 React 的原因了吧,毕竟它可是我见一个爱一个的技术之一🤣🤣🤣


也正是因为这个原因,在 React 中编写一个组件就给我们编写一个组件提供了多种方式,那么在接下来的文章中我们就来讲解一下这几种组件的设计模式。


Mixin设计模式


在上一篇文章中有讲解到了 JavaScript 中的 Mixin,如果对这个设计模式不太理解的可以通过这篇文章进行学习 来学习一下 JavaScript 中的 Mixin


如何在多个组件之间共享代码,是开发者们在学习 React 是最先问的问题之一,你可以使用组件组合来实现代码重构,你也可以定义一个组件并在其他几个组件中使用它。


如何用组合来解决某个模式并不是显而易见的,React 受函数式编程的影响,但是它进入了由面向对象库主导的领域(hooks 出现以前),为了解决这个问题,React 团队在这加上了 Mixin,它的目标就是当你不确定如何使用组合解决想用的问题时,为你提供一种在组件之间重用代码。


React 最主流构建 Component 的方法是利用 createClass 创建,顾名思义,就是创造一个包含 React 方法 Class 类。


Mixin危害


React 官方文档 Mixins Considered Harmful 中提到了 Mixin 带来的危害,主要有以下几个方面:



  • Mixin 可能会相互依赖,相互耦合,不利于代码维护;

  • 不同的 Mixin 中的方法可能会相互冲突;

  • Mixin非常多时,组件是可以感知到的,甚至还要为其做相关处理,这样会给代码造成滚雪球式的复杂性;


装饰器模式


装饰器是一种特殊的声明,可以附加到类声明、方法、访问器、属性或参数上,装饰者使用 @+函数名 形式来修改类的行为。如果你对装饰器不太了解,你可以通过这一篇文章 TS的装饰器你再学不会我可就要报警了哈 进行学习。


现在我们来看看在 React 中怎么使用装饰器,我们现在有这样的一个需求,就是为被装饰的页面或组件设置统一的背景颜色和自定义颜色,完整代码具体如下:


import React, { Component } from "react";

interface Params {
background: string;
size?: number;
}

function Controller(params: Params) {
return function (
WrappedComponent: React.ComponentClass,
): React.ComponentClass {
WrappedComponent.prototype.render = function (): React.ReactNode {
return <div>但使龙城飞将在,不教胡马度阴山</div>;
};

return class Page extends Component {
render(): React.ReactNode {
const { background, size = 16 } = params;
return (
<div style={{ backgroundColor: background, fontSize: size }}>
<WrappedComponent {...this.props}></WrappedComponent>
</div>

);
}
};
};
}

@Controller({ background: "pink", size: 100 })
class App extends Component {
render(): React.ReactNode {
return <div>牛逼</div>;
}
}

export default App;

这段代码的具体输出如下所示:


image.png


在上面的代码中,Controller 装饰器会接收 App 组件,其中 WrappedComponent 就是我们的 App 组件,在这里我们通过修改原型方法 render 将其的返回值修改了,并对其进行了一层包裹。


所以 App 组件在使用了类装饰器,不仅可以修改了原来的 DOM,还对外层多加了一层包裹,理解起来就是接收需要装饰的类为参数,返回一个新的内部类。恰与 HOC 的定义完全一致。所以,可以认为作用在类上的 decorator 语法糖简化了高阶组件的调用。


高阶组件


HOC 高阶组件模式是 React 比较常用的一种包装强化模式之一,你也可以看作 React 对装饰模式的一种实现,高阶组件就是一个函数,并且该函数接收一个组件作为参数,并返回一个新的组件,它是一种设计模式,这种设计模式是由 React 自身的特性产生的结果。


高阶组件主要解决了以下问题,具体如下:



  • 复用逻辑: 高阶组件就像是一个加工 React 组件的工厂,你需要向该工厂提供一个坯子,它可以批量地对你送进来的组件进行加工,包装处理,还可以根据你的需求定制不同的产品;

  • 强化props: 高阶组件返回的组件,可以劫持上一层传过来的 props,染回混入新的 props,来增强组件的功能;

  • 控制渲染: 劫持渲染是 hoc 中的一个特性,在高阶组件中,你可以对原来的组件进行条件渲染,节流渲染,懒加载等功能;


HOC的实现方式


常用的高阶组件有两种方式,它们分别是 正向属性代理反向继承,接下来我们来看看这两者的区别。


正向属性代理


所谓正向属性代理,就是用组件包裹一层代理组件,在代理组件上,我们可以代理所有传入的 props,并且觉得如何渲染。实际上这种方式生成的高阶组件就是原组件的父组件,父组件对子组件进行一系列强化操作,上面那个装饰器的例子就是一个 HOC 正向属性代理的实现方式。


对比原生组件增强的项主要有以下几个方面:



  • 可操作所有传入的props: 可以对其传入的 props 进行条件渲染,例如权限控制等;

  • 可以操作组件的生命周期;

  • 可操作组件的 static 方法,但是需要手动处理,或者引入第三方库;

  • 获取 refs;

  • 抽象 state;


反向继承


反向继承其实是一个函数接收一个组件作为参数传入,并返回了一个继承自该传入的组件的类,并且在该类的 render() 方法中返回 super.render() 方法,能通过 this 访问到源组件的生命周期propsstaterender等,相比属性代理它能操作更多的属性。


两者区别



  • 属性代理是从组合的角度出发,这样有利于从外部操作被包裹的组件,可以操作的对象是 props,或者加一层拦截器或者控制器等;

  • 方向继承则是从继承的角度出发,是从内部去操作被包裹的组件,也就是可以操作组件内部的 state,生命周期,render 函数等;


具体实例代码如下所示:


function Controller(WrapComponent: React.ComponentClass) {
return class extends WrapComponent {
public state: State;
constructor(props: any) {
super(props);
this.state = {
nickname: "moment",
};
}

render(): React.ReactNode {
return super.render();
}
};
}

interface State {
nickname: string;
}

@Controller
class App extends Component {
public state: State = {
nickname: "你小子",
};
render(): React.ReactNode {
return <div>{this.state.nickname}</div>;
}
}

反向继承主要有以下优点:



  • 可以获取组件内部状态,比如 state,props,生命周期事件函数;

  • 操作由 render() 输出的 React 组件;

  • 可以继承静态属性,无需对静态属性和方法进行额外的处理;


反向继承也存在缺点,它和被包装的组件强耦合,需要知道被包装的组件内部的状态,具体是做什么,如果多个反向继承包裹在一起,状态会被覆盖。


HOC的实现


HOC 的实现方式按照上面讲到的两个分类一样,来分别讲解这两者有什么写法。


操作 props


该功能由属性代理实现,它可以对传入组件的 props 进行增加、修改、删除或者根据特定的 props 进行特殊的操作,具体实现代码如下所示:


import React, { Component } from "react";

interface Params {
background: string;
size?: number;
}

function Controller(params: Params) {
return function (
WrappedComponent: React.ComponentClass,
): React.ComponentClass {
WrappedComponent.prototype.render = function (): React.ReactNode {
return <div>但使龙城飞将在,不教胡马度阴山</div>;
};

return class Page extends Component {
render(): React.ReactNode {
const { background, size = 16 } = params;
return (
<div style={{ backgroundColor: background, fontSize: size }}>
<WrappedComponent {...this.props}></WrappedComponent>
</div>

);
}
};
};
}

@Controller({ background: "pink", size: 100 })
class App extends Component {
render(): React.ReactNode {
return <div>牛逼</div>;
}
}

export default App;

抽离state控制组件更新


高阶组件可以将 HOCstate 配合起来,控制业务组件的更新,在下面的代码中,我们将 inputvalue 提取到 HOC 中进行管理,使其变成受控组件,同时不影响它使用 onChange 方法进行一些其他操作,具体代码如下所示:


function Controller(WrappedComponent) {
return class extends React.Component {
constructor(props) {
super(props);
this.state = {
name: "",
};
this.onChange = this.onChange.bind(this);
}

onChange = (event) => {
this.setState({
name: event.target.value,
});
};

render() {
const newProps = {
value: this.state.name,
};
return (
<WrappedComponent
onChange={() =>
this.onChange}
{...this.props}
{...newProps}
/>

);
}
};
}

class App extends React.Component {
render() {
return (
<div>
<h1>{this.props.value}</h1>
<input name="name" {...this.props} />
</div>

);
}
}

export default Controller(App);

获取 Refs 实例


使用高阶组件后,获取到的 ref 实例实际上是最外层的容器组件,而非原组件,但是很多情况下我们需要用到原组件的 ref,我们先来看下面的代码,具体代码如下所示:


function Controller(WrappedComponent) {
return class Page extends React.Component {
render() {
const { ref, ...rest } = this.props;
return <WrappedComponent {...rest} ref={ref} />;
}
};
}

class Input extends React.Component {
render() {
return <input />;
}
}

class App extends React.Component {
constructor(props) {
super(props);
this.ref = React.createRef();
}
componentDidMount() {
console.log(this.ref);
}
render() {
return <Input ref={this.ref} />;
}
}

export default Controller(App);

image.png


通过查看控制台输出,你会发现获取到的是整个 Input 组件,那么有什么办法可以获取到 input 这个真实的 DOM 呢?


在之前的例子中我们可以通过 props 传递,一层一层传递给 input 原生组件来获取,具体代码如下:


class Input extends React.Component {
render() {
return <input ref={this.props.inputRef} />;
}
}

注意,因为传参不能传 ref,所以这里要修改一下


image.png


当然你也可以利用父组件的回调,具体代码如下:


class App extends React.Component {
constructor(props) {
super(props);
this.ref = React.createRef();
}
componentDidMount() {
console.log(this.ref);
}
render() {
return <Input inputRef={(e) => (this.ref = e)} />;
}
}

最终的代码如下图所示,这里展示了以上两个方法具体代码,如下图所示:


image.png


通过查看浏览器输出,两者都能成功输出原生的 ref 实例


image.png


React 给我们提供了一个 forwardRef 来帮助我们进行 refs 传递,这样我们在高阶组件上获取的 ref 实例就是原组件的 ref 了,而不需要手动传递,我们只需要修改一下 Input 组件代码即可,具体如下:


const Input = React.forwardRef((props, ref) => {
return <input type="text" ref={ref} />;
});

image.png


这样我们就获取到了原始组件的 ref 实例啦!


获取原组件的 static 方法


当待处理的组件为 class 组件时,通过属性代理实现的高阶组件可以获取到原组件的 static 方法,具体实现代码如下所示:


function Controller(WrappedComponent) {
return class Page extends React.Component {
componentDidMount() {
WrappedComponent.moment();
}
render() {
const { ref, ...rest } = this.props;
return <WrappedComponent {...rest} ref={ref} />;
}
};
}

class App extends React.Component {
static moment() {
console.log("你好骚啊");
}
render() {
return <div>你小子</div>;
}
}

export default Controller(App);

你好骚啊 正常输出


image.png


反向继承操作 state


因为我们高阶组件继承了传入组件,那么就是能访问到this了,有了 this 我们就能操作和读取 state,也就不用像属性代理那么复杂还要通过 props 回调来操作 state


反向继承的基本实现方法就是原组件继承 Component,再在高阶组件中通过把原组件传参,再生成一个继承自原组件的组件。


image.png


具体实例代码如下所示:


function Controller(WrappedComponent) {
return class Page extends WrappedComponent {
componentDidMount() {
console.log(`组件挂载时 this.state 的状态为`, this.state);
setTimeout(() => {
this.setState({ nickname: "你个叼毛" });
}, 1000);
// this.setState({ nickname: 1 });
}
render() {
return super.render();
}
};
}

class App extends React.Component {
constructor() {
super();
this.state = {
nickname: "你小子",
};
}
render() {
return <h1>{this.state.nickname}</h1>;
}
}

export default Controller(App);

代码具体输出如下图所示,当组件挂载完成之后经过一秒,state 状态发生改变:


image.png


劫持原组件生命周期


因为反向继承方法实现的是高阶组件继承原组件,而返回的新组件属于原组件的子类,子类的实例方法会覆盖父类的,具体实例代码如下所示:


function Controller(WrappedComponent) {
return class Page extends WrappedComponent {
componentDidMount() {
console.log("生命周期方法被劫持啦");
}
render() {
return super.render();
}
};
}

class App extends React.Component {
componentDidMount() {
console.log("原组件");
}
render() {
return <h1>你小子</h1>;
}
}

export default Controller(App);

代码的具体输出如下图所示:


image.png


render props 模式


render props 的核心思想是通过一个函数将组件作为 props 的形式传递给另外一个函数组件。函数的参数由容器组件提供,这样的好处就是将组件的状态提升到外层组件中,具体实例代码如下所示:


const Home = (props) => {
console.log(props);
const { children } = props;
return <div>{children}</div>;
};

const App = () => {
return (
<div>
<Home admin={true}>
<h1>你小子</h1>
<h1>小黑子</h1>
</Home>
</div>

);
};

export default App;

具体的代码运行结果如下图所示:


image.png


虽然这样能实现效果,但是官方说这是一个傻逼行为,因此官方更推荐使用 React 官方提供的 Children 方法,具体实例代码如下所示:


const Home = (props) => {
console.log(props);
const { children } = props;
return <div>{React.Children.map(children, (node) => node)}</div>;
};

const App = () => {
return (
<div>
<Home admin={true}>
<h1>你小子</h1>
<h1>小黑子</h1>
</Home>
</div>

);
};

export default App;

具体更多信息请参考 官方文档


实际上,我们经常使用的 context 就是使用的 render props 模式。


反向状态回传


这个组件的设计模式很叼很骚,就是你可以通过 render props 中的状态,提升到当前组件中也就是把容器组件内的状态,传递给父组件,具体示例代码如下所示:


import React, { useRef, useEffect } from "react";

const Home = (props) => {
console.log(props);
const dom = useRef();
const getDomRef = () => dom.current;
const handleClick = () => {
console.log("小黑子");
};
const { children } = props;
return (
<div ref={dom}>
<div>{children({ getDomRef, handleClick })}</div>
<div>{React.Children.map(children, (node) => node)}</div>
</div>

);
};

const App = () => {
const childRef = useRef(null);
useEffect(() => {
const dom = childRef.current();
dom.style.background = "red";
dom.style.fontSize = "100px";
}, [childRef]);

return (
<div>
<Home admin={true}>
{({ getDomRef, handleClick }) => {
childRef.current = getDomRef;

return <div onClick={handleClick}>你小子</div>;
}}
</Home>
</div>

);
};

export default App;

在运行代码之后,我们首先点击一下 div 元素,具体有如下输出,请看下图:


image.png


你会看到成功的在父组件操作到了子组件的 ref 实例了,还获取到了子组件的 handleClick 函数并成功调用了。


提供者模式


考虑一下这个场景,就好像爷爷要给孙子送吃的,按照之前的例子中,要通过 props 的方式把吃的送到孙子手中,你首先要经过儿子手中,再由儿子传给孙子,那万一儿子偷吃了呢?孙子岂不是饿死了.....


为了解决这个问题,React 提供了 Context 提供者模式,它可以直接跳过儿子直接把吃的送到孙子手上,具体实例代码如下所示:


import React, { createContext, useContext } from "react";

const ThemeContext = createContext({ nickname: "moment" });

const Foo = () => {
const theme = useContext(ThemeContext);
return <h1>{theme.nickname}</h1>;
};

const Home = () => {
const theme = useContext(ThemeContext);
return <h1>{theme.nickname}</h1>;
};

const App = () => {
const theme = useContext(ThemeContext);

return (
<div>
{
<ThemeContext.Provider
value={{
nickname: "你小子",
}}
>

<Foo />
</ThemeContext.Provider>
}
{
<ThemeContext.Provider
value={{
nickname: "首页",
}}
>

<Home />
</ThemeContext.Provider>
}
<div>{theme.nickname}</div>
</div>

);
};

export default App;

代码输出如下图所示:


image.png


到这里本篇文章也就结束了,Hooks 的就不讲啦,在这篇文章中有讲到一点,喜欢的可以看看 如何优雅设地计出不可维护的 React 组件


参考资料



总结


不管是使用高阶组件、render propscontext亦或是 Hooks,它们都有不同的使用场景,不能说哪个好用,哪个不好用,这就要根据到你的业务场景了,最后不得不说,React,你是真的骚啊......


最后希望这篇文章对你有帮助,如果错漏,欢迎留言指出,最后祝大嘎假期快来!


作者:Moment
来源:juejin.cn/post/7230461901356154940
收起阅读 »

别再删到手抽筋!JS中删除数组元素指南

web
作为一名前端开发工程师,我们经常需要在 JavaScript 中操作数组,其中比较常见的操作便是对数组进行元素的添加、删除和修改。在这篇文章中,我会详细介绍JS中所有删除数组元素的方法。 删除数组元素之splice() splice()方法可以向数组任意位置插...
继续阅读 »

cover.png


作为一名前端开发工程师,我们经常需要在 JavaScript 中操作数组,其中比较常见的操作便是对数组进行元素的添加、删除和修改。在这篇文章中,我会详细介绍JS中所有删除数组元素的方法。


删除数组元素之splice()


splice()方法可以向数组任意位置插入或者删除任意数量的元素,同时返回被删除元素组成的一个数组。


const arr = ['a', 'b', 'c', 'd', 'e'];
arr.splice(1, 2);//删除数组下标为1、2的元素
console.log(arr); // ["a", "d", "e"]

通过上述代码,可以看到元素'b'和'c'已被删除,被删除的元素以数组形式返回。需要注意的是,该方法会改变原数组,因此使用时应该谨慎。


删除数组元素之filter()


filter() 方法创建一个新数组,其包含通过所提供函数实现的测试的所有元素。它不会改变原始数组。


const arr = [10, 2, 33, 5];
const newArr = arr.filter(item => item !== 2);//过滤掉值为2的元素
console.log(newArr); //[10, 33, 5]

以上代码展示了如何使用 filter() 方法删除数组内某些元素。其中箭头函数 (item) => item !== 2 表示过滤掉数组元素中值为2的元素。


删除数组元素之pop()


pop() 方法用于删除并返回数组的最后一个元素。


const arr = [1, 2, 3];
const lastItem = arr.pop(); //删除元素3,lastItem为3
console.log(lastItem); //3
console.log(arr); //[1, 2]

通过上述代码可以看到,使用 pop() 方法可以非常容易地删除数组的最后一个元素。


删除数组元素之shift()


shift() 方法用于删除并返回数组的第一个元素。


const arr = [1, 2, 3];
const firstItem = arr.shift(); //删除元素1,firstItem为1
console.log(firstItem); //1
console.log(arr); //[2, 3]

与pop()类似, shift() 方法也是从数组中删除元素。但与 pop() 不同的是,它从数组头部开始删除。


删除数组元素之splice()、slice()和concat()组合操作


刚才已经讲到了 splice()方法的删除功能,现在我们还可以将slice()concat() 结合起来使用进行删除。


let arr = ['a', 'b', 'c', 'd', 'e'];
arr = arr.slice(0, 1).concat(arr.slice(2));//删除数组下标为1的元素
console.log(arr);//["a", "c", "d", "e"]

通过以上代码可以看出,使用 slice() 方法获取要删除的元素前面和后面的元素,最后使用 concat() 将两个数组合并成为一个新的数组。


删除数组元素之使用ES6中的扩展运算符


在ES6中,spread operator扩展运算符是用来展开一个可迭代对象,比如用于函数调用时的展开数组等。


let arr = ['a', 'b', 'c', 'd', 'e'];
arr = [...arr.slice(0, 1), ...arr.slice(2)];//删除数组下标为1的元素
console.log(arr);//["a", "c", "d", "e"]

通过以上代码可以看出,使用ES6中的扩展运算符(...)也可以方便地删除数组内某些元素。


总结


不同方法适用于不同情境,具体的使用应该根据情况而定。总体而言, splice()filter() 是两个最常用的方法,pop()shift() 则适合删除特定位置的元素。而在多种情况下,不同的操作组合也能实现有效删除。至于如何更好地使用这些方法,还需要根据实际情况进行深入应用和理解。


希望本文对你有所帮助,同时也欢迎拓展其他新颖的删除数组元素的方法。


作者:𝑺𝒉𝒊𝒉𝑯𝒔𝒊𝒏𝒈
来源:juejin.cn/post/7230460443189690405
收起阅读 »

移动端旅行网站页面

web
一、布局 1、首页 (1)头部 iconfont的使用和代码优化 iconfont.css中修改路径 引入iconfont.css import text-align: center(文字水平居中) 优化: 变量复用:src/assets/styles/...
继续阅读 »

一、布局


1、首页


(1)头部


iconfont的使用和代码优化



  • iconfont.css中修改路径

  • 引入iconfont.css import


text-align: center(文字水平居中)


优化:


  1. 变量复用:src/assets/styles/varibles.styl中定义变量 $变量名=值。在style中引入样式,@import(样式中引入样式需加@符号)

  2. 路径名过长:在css中引入其他的css想使用@符号,必须在@符号前加上~(@表示src目录)

  3. 路径别名:


build/webpack.base.conf.js->resolve->alias->创建别名


resolve: {
extensions: ['.js', '.vue', '.json'],
alias: {
'vue$': 'vue/dist/vue.esm.js',
'@': resolve('src'),
//创建别名
'styles': resolve('src/assets/styles'),
'common':resolve('src/common')
}
}

报错原因:修改webpack中的内容后需要重启服务器


(2)轮播图


Swiper插件原理


Swiper是一款基于JavaScript的开源滑动插件,可以用于制作各种类型的轮摇图、滑动菜单、图片预览等。Swiper 的原理主要是通过监听用户的手势操作来实现滑动效果,同时利用CSS3动画和过渡效果来实现平滑的过渡和动画效果。



  1. 监听手势操作


Swiper通过监听用户的手势操作来实现滑动效果,具体包括touchstart、touchmove.touchend符事件。在touchstart 事件中,Swiper记录下用户的触摸起始位置及时间,touchmove事件中,Swiper根据用户移动的距离和时间计算出滑动速度和方向,从而控制滑动的行为;touchend事件中,Swiper根据滑动的距离和速度来判断是否进行下一张图片的切换。



  1. 切换图片


Swiper通过获取当前显示的图片索引及方向来计算出下一张图片的索引,并通过CSS3过渡效果来实现平滑的图片切换。同时,Swiper可以支持多种不同的切换效果,包括淡入淡出、渐变、滑动、翻转等,



  1. 响应式设计


Swiper支持响应式设计,可以根据不同的设备尺寸和屏幕方向来自动调整轮播图的大小和样式,从而提供更好的用户体验。同时,Swiper还支持自定义参数配置,可以灵活地控制轮播图的各种属性和行为。


问题


网速慢时图片没有加载出来造成的抖动(使用padding-bottom占位):


overflow: hidden
height:0
padding-bottom: 31.25% //高宽比

显示分页:


<!-- template -->
<swiper :options="swiperOption" v-if="showSwiper">
<!-- slides -->
<!-- 循环实现轮播图 -->
<swiper-slide v-for="item of list" :key="item.id">
<img class="swiper-img" :src="item.imgUrl" alt="">
</swiper-slide>
<!-- 插槽 -->
<div class="swiper-pagination" slot="pagination"></div>
</swiper>

// script
export default {
name: 'HomeSwiper',
props: {
list:Array
},
data() {
return {
swiperOption: {
// 设置显示轮播图分页
pagination: ".swiper-pagination",
//设置轮播图循环展示
loop: true,
// 设置自动轮播及间隔时间
autoplay: 3000
},
}
},
computed: {
// 列表为空时不显示轮播图
showSwiper() {
return this.list.length;
}
}
}

样式穿透



  • >>>

  • /deep/

  • ::v-deep



  1. 引入第三方组件库(如element-ui、element-plus),修改第三方组件库的样式。

  2. 样式文件中使用了 scoped 属性,但是为了确保每个组件之间不存在相互影响所以不能去除


/* style */
.wrapper >>> .swiper-pagination-bullet
background-color: #fff

插槽slot


通过slot插槽将页面中具体的数据传递给swiper组件,希望组件的内容可以被父组件定制的时候,使用slot向组件传递内容。


(3)图标区域


图标的轮播实现


使用computed计算功能实现图标的多页显示(容量为8,多出来的的图标换页显示):


computed: {
pages () {
// 创建二维数组pages
const pages = [];
// 对图标列表使用forEach循环
this.list.forEach((item, index) => {
// 计算页码
const page = Math.floor(index/8);
if (!pages[page]){
pages[page] = []
}
pages[page].push(item)
});
// pages[0]中存储在第一页显示的图标,以此类推
return pages
},
showIcon() {
return this.list.length
}
}

优化:


(1)希望文字过多时有…提示:


css中添加:


overflow: hidden
white-space:nowrap
text-overflow:ellipsis

(2)重复代码封装:


借助stylus提供的mixin对代码进行封装:


src/assets/varibles.styl中定义ellipse方法,在css中@import 文件,直接使用ellipse()


mixin(混入)

它提供了一种非常灵活的方式,来分发 Vue 组件中的可复用功能。


使用场景: 不同组件中经常会用到一些相同或相似的代码,这些代码的功能相对独立。可以通过mixin 将相同或相似的代码提出来。


缺点:



  1. 变量来源不明确

  2. 多 mixin 可能会造成命名冲突(解决方式:Vue 3的组合API)

  3. mixin 和组件出现多对多的关系,使项目复杂度变高。


(4)推荐


text-indent:文字缩进


使用ellipsis()不起作用:父元素添加min-width: 0


(5)周末游


(6)Ajax获取首页数据


安装axios,引入axios


import axios from 'axios'
methods: {
getHomeInfo() {
// 使用axios.get()请求一个URL,返回的对象是一个promise对象,使用.then()获取
axios.get('/api/index.json?city='+this.city)
.then(this.getHomeInfoSucc);
},

getHomeInfoSucc(res) {
res = res.data;
if (res.ret && res.data) {
const data = res.data
// this.city = data.city
this.swiperList = data.swiperList
this.iconList = data.iconList
this.recommendList = data.recommendList
this.weekendList = data.weekendList
}
}
}

转发机制(开发环境的转发)



  • 只有static文件夹下的内容才可以被外部访问到

  • 现在用的是本地模拟的接口地址,假如代码要上线,肯定不能填成这样的一个地址,那么就需要在上线之前把这块儿的东西都重新替换成API这种格式,上线之前去改动代码儿是有风险的

  • 转发机制:webpack-dev-server提供 proxyTable 配置项,config/index.js 中proxyTable


module.exports = {
dev: {
// Paths
assetsSubDirectory: 'static',
assetsPublicPath: '/',
// 请求api目录时将请求转发到当前服务器的8080端口上,但是路径替换为/static/mock
proxyTable: {
'/api':{
target: 'http://localhost:8080',
pathRewrite: {
'^/api': '/static/mock'
}
}
}
}


  • 整个首页发送一个ajax请求而不是每个组件发送一个


(7)首页父子组件数据传递


父->子:属性传值,子组件props:{}接收


轮播图默认显示最后一张图


原因:


还没有接收ajax数据时,swiper接收的数据是一个空数组,当接受ajax数据后, swiperList变成真正的数据项。再传给home-swiper这个组件的时候,它才获取到新的数据,然后重新渲染了新数据对应的很多的幻灯片。因为swiper的初始化创建是根据空数组创建的,所以会导致默认显示的是所有的这个页面中的最后一个页面。


解决:


让swiper的初次创建由完整的数据来创建,而不是由那个空数组来创建。只需要写一个v-if,再写一个list.length。当传递过来的list是个空数组的时候,v-if的值是false,所以swiper不会被创建。只有等真正的数据过来了之后才会被创建。由于模板中尽量少出现逻辑性代码,所以创建一个计算属性computed,计算 list.length。


取消轮播图自动播放:autoplay: false


2、城市选择页


(1)路由配置


路由跳转:


import Vue from 'vue'
import Router from 'vue-router'
import Home from '../pages/home/Home'
import City from '../pages/city/City'
import Detail from '../pages/detail/Detail'

Vue.use(Router)

export default new Router({
routes: [{
path: '/',
name: 'Home',
component: Home
},
{
path: '/city',
name: 'City',
component: City
},
{
// 动态路由
path: '/detail/:id',
name: 'Detail',
component: Detail
}
],
scrollBehavior (to, from, savedPosition) {
return { x: 0, y: 0 }
}
})

使用:


<router-link to="/city">
<div class="header-right">
{{this.city}}
<span class="iconfont arrow-icon">&#xe600;</span>
</div>

</router-link>

(2)搜索框


定义一个keyword数据,与搜索框使用v-model做双向数据绑定。


<div class="search">
<input v-model="keyword" class="search-input" type="text" placeholder="输入城市名或拼音" />
</div>

City.vue父组件向Search.vue组件传值(cities),Search.vue接收cities


使用watch监听keyword的改变(使用节流)


解决匹配城市过多无法滚动问题


import Bscroll,在mounted中创建一个BScroll, this.scroll = new BScroll(this.$refs.search),通过$ref获取需要滚动的元素。


<!--搜索结果显示框-->
<div class="search-content" ref="search" v-show="keyword">
<ul>
<!--解决删除输入列表依然存在的问题-->
<li class="search-item border-bottom" v-for="item in list" :key="item.id" @click="handleCityClick(item.name)">{{item.name}}</li>
<li class="search-item border-bottom" v-show="hasNoData">没有找到匹配数据</li>
</ul>
</div>

优化


1.解决删除输入列表依然存在的问题:v-show = "keyword"

2.没有找到匹配项时,显示“没有找到匹配数据”:v-show = "!this.list.length"

双向数据绑定原理(搜索时使用)




  • 概念:

    Vue 中双向绑定是一个指令v-model,可以绑定一个响应式数据到视图,同时视图的变化能改变该值。v-model是语法糖,默认情况下相当于:value@inputv-bind:valuev-on:input),使用v-model可以减少大量繁琐的事件处理代码,提高开发效率。




  • 使用:

    通常在表单项上使用v-model,还可以在自定义组件上使用,表示某个值的输入和输出控制。




  • 原理:

    v-model是一个指令,双向绑定实际上是Vue 的编译器完成的,通过输出包含v-model模版的组件渲染函数,实际上还是value属性的绑定及input事件监听,事件回调函数中会做相应变量的更新操作。




(3)列表


引入区块滚动


子元素使用float,父元素开启BFC(overflow:hidden)去除高度塌陷。


使列表区域无法滚动(position:absolute + overflow:hidden),然后使用better-scroll插件


better-scroll



  • 安装better-scroll包。

  • 需要 better-scroll 包裹的所有元素最外层需要使用一个div包裹,并设置一个ref属性方便创建scroll。

  • 创建scroll


<div class="list" ref="wrapper">list中的元素<div>

import Bscroll from 'better-scroll'
// 写在mounted钩子函数中,此时页面挂载完成,可以操作DOM元素。
mounted() {
this.scroll = new Bscroll(this.$refs.wrapper)
}

$ref


ref属性:获取DOM。


在vue中ref可以以属性的形式添加给标签或者组件:



  • ref 写在标签上时:this.$refs.ipt 获取的是添加了ref="ipt"标签对应的dom元素;

  • ref 写在组件上时:this.$refs['component'] 获取到的是添加了ref="component"属性的这个组件。


$refs 是所有注册过 ref 的集合(对象);若是遍历的ref,则对应$refs是个数组集合


注意:$refs不是响应式的,只在组件渲染完成之后才填充。所以想要获取DOM数据的更新要使用 this.$nextTick()


字母表和城市列表字母的联动


兄弟组件传值:


Alphabet组件将值传递给父组件City.vue,父组件将值传递给子组件List.vue实现字母表和城市列表字母的联动。


为每个字母绑定一个onclick事件,在方法中使用this.$emit向外传递change事件。


<!--Alphabet.vue-->
<template>
<ul class="list" >
<li class="item" v-for="key in letters"
:key="key"
:ref="key"
@touchstart="handleTouchStart"
@touchmove="handleTouchMove"
@touchend="handleTouchEnd"
@click="handleLetterClick"
>

{{key}}
</li>
</ul>
</template>


// Alphabet.vue
methods: {
handleLetterClick (e) {
// 向外(City.vue)传递事件
this.$emit("change", e.target.innerText);
}
}

父组件


<!--City.vue-->
<city-alphabet :cities="cities" @change="handleLetterChange"></city-alphabet>

// City.vue
data () {
return {
letter: '' // 被点击的字母
}
},
methods: {
handleLetterChange (letter) {
this.letter = letter;
// console.log(letter);
}
}

<!-- 向List组件传值letter -->
<city-list :cities="cities" :hot="hotCities" :letter="letter"></city-list>

// List.vue接收letter
props: {
hot: Array,
cities: Object,
letter: String
},

使用watch监听letter变化,当letter发生变化时,调用this.scroll.scrollToElement()方法将区域自动滚动到指定区域,在template中给每一个area区域加一个:ref='key',通过this.$refs[this.letter][0]获取值为this.letter的DOM元素。


<div class="area" v-for="(item, key) in cities" :key="key" :ref="key" >
<div class="title border-topbottom">{{ key }}</div>
<div class="item-list">
<div class="item border-bottom" v-for="innerItem in item" :key="innerItem.id" @click="handleCityClick(innerItem.name)">{{innerItem.name}}</div>
</div>
</div>

watch: {
letter () {
if (this.letter) {
// 获取值为`this.letter`的DOM元素
const element = this.$refs[this.letter][0]
// 将区域自动滚动到指定区域
this.scroll.scrollToElement(element)
}
}
}

上下拖拽字母表touch

为字母表绑定三个事件:


@touchstart="handleTouchStart"  //手指开始触摸时设置this.touchStatus = true
@touchmove="handleTouchMove" //在true时对触摸事件做处理
@touchend="handleTouchEnd" //手指结束触摸时设置this.touchStatus = false

// 构建字母数组
computed: {
// 构建字母数组["A", "B", ……, "Z"]
letters () {
const letters = [];
for (let i in this.cities){
letters.push(i);
}
return letters;
}
},
methods: {
handleLetterClick (e) {
// 向外(City.vue)传递事件
this.$emit("change", e.target.innerText);

},
handleTouchStart () {
this.torchStatus = true;
},
handleTouchMove (e) {
if (this.torchStatus) {
// 如果timer已经存在,去除timmer(即上一次的事件还未执行完毕又出发了下一次事件,就用下一次事件覆盖上一次的事件)
if (this.timer){
clearTimeout(this.timer)
}
// 否则就创建一个timer
//节流,将操作延迟16ms执行,如果上一个操作间隔小于16ms,则清除上一个操作,直接执行这次操作,减少handleTouchMove的使用频率
this.timer = setTimeout(() => {
const touchY = e.touches[0].clientY - 79; // 当前手指触摸位置与头部下沿的距离,79px为头部的高度
const index = Math.floor((touchY - this.startY) / 20); //当前手指触摸位置的元素
// 合法时向父元素emit change事件
if (index >= 0 && index < this.letters.length){
this.$emit('change', this.letters[index]);
}
}, 16)

}
},
handleTouchEnd () {
this.torchStatus = false
}
}

优化

1、将字母A到头部下沿的距离的计算放在updated生命周期钩子函数中


初始时cities值为0,当Ajax获取数据后,cities的值才发生变化,AlphaBet才被渲染出来, 当往alphabet里面传的数据发生变化的时候,alphabet这个组件儿就会重新渲染。之后,updated这个生命周期钩子就会被执行。这个时候,页面上已经展示出了城市字母列表里所有的内容,去获取A这个字母所在的dom对应的offsettop的值就没有任何的问题了。


2、节流


如果timer已经存在,去除timmer(即上一次的事件还未执行完毕又出发了下一次事件,就用下一次事件覆盖上一次的事件)。


否则就创建一个timer,将操作延迟16ms执行,如果上一个操作间隔小于16ms,则清除上一个操作,直接执行这次操作,减少handleTouchMove的使用频率。


3、使用Vuex实现首页和城市选择页面的数据共享



  1. 安装vuex

  2. 创建src/store/index.js文件


import Vue from 'vue'
import Vuex from 'vuex'
import state from './state'
import mutations from './mutations'

Vue.use(Vuex)

export default new Vuex.Store({
state,
// actions: {
// changeCity (ctx, city) {
// ctx.commit('changeCity', city)
// }
// },
mutations
})


  1. main.js中引入store


import store from './store'


  1. 在mainjs中创建根实例时将store传入,store会被派发到每个子组件中,每个子组件中都可以使用this.$store获取到 store。


new Vue({
el: '#app',
router,
store,
components: { App },
template: '<App/>'
})

(1)Vuex


概念


Vuex 是 Vue 专用的状态管理库,它以全局方式集中管理应用的状态,并以相应的规则保证状态以一种可预测的方式发生变化。主要解决的问题是多组件之间状态共享。


image.png


核心概念



  • State:存放核心数据

  • Action:异步方法

  • Mutation:同步的对数据的改变

  • Getter:类似于计算属性,提供新的数据,避免数据的冗余

  • Module:模块化,拆分


image.png


项目中Vuex的使用



  • state存放当前城市CurCity

  • 为每个城市元素都绑定一个onclick事件(获取改变的city),点击城市

  • 在List组件中调用dispatch方法->触发Action

  • 在store/index.js中增加一个actions对象(接收city),使用commit调用mutation

  • mutations中,令state.city = city,完成


// List.vue
this.$store.dispatch('changeCity', city)

// store/index.js
actions: {
changeCity (ctx, city) {
// 使用Commit调用Mutation
ctx.commit('changeCity', city)
}

},
mutations: {
changeCity (state, city) {
state.city = city;
try {
localStorage.city = city
} catch (e) {}
}
}

image.png


(2)单页面与多页面


实现单页面跳转的方式



  1. 标签实现



  • a标签

  • router-link标签


<a href="#/xxx" />
<router-link to="/xxx" />


  1. 函数实现



  • 传统的window.location.href

  • 使用vue-router中的router对象 (点击城市后自动跳转到首页)
    step1 定义一个实现onclik事件的组件


<a onClick={this.goTo} />

step2 在goTo函数中实现跳转


goTo = () => {
// 方案1 传统的window.location.href
window.location.href = "#/xxx"

// 方案2 使用vue-router中的router对象
this.$router.push('/');
}

项目中,点击城市后跳转到首页:this.$router.push


methods: {
handleCityClick (city) {
this.$router.push('/');
}
},

(3)localStorage(state和mutations中使用)


//state.js
let defaultCity = "上海"
try {
if (localStorage.city){
defaultCity = localStorage.city
}
}catch (e) {}

export default{
city: defaultCity
}

// mutation.js
export default{
changeCity (state, city) {
state.city = city;
try {
localStorage.city = city
} catch (e) {}

}
}

(4)keep-alive优化网页性能


每次切换回组件时,组件就会被重新渲染,mounted生命周期钩子就会被重新执行,ajax数据就会被重新获取,导致性能低。


<!-- App.vue -->
<keep-alive>
<router-view/>
</keep-alive>

使用keep-alive后会多出两个生命周期钩子函数activated和deactivated
activated在每次切换回组件时调用,因此可以在activated中定义方法,在城市切换时重新发送ajax请求。


4、景点详情页


(1)动态路由及banner分支


为recommend组件的li标签外部包裹一个router-link标签,li标签样式改变,解决方式:


将li标签直接替换为router-link标签, 加入一个tag=“li”的属性,动态绑定::to = "'/detail/' + item.id",在router/index.js设置Detail路由


<!-- recommend.vue -->
<router-link tag="li"
class="item border-bottom"
v-for="item in list"
:key="item.id"
:to="'/detail/' + item.id">

</router-link>

// router/index.js
{
path: '/detail/:id',
name: 'Detail',
component: Detail
}

图片底部渐变效果:


background-image: linear-gradient(top, rgba(0, 0, 0, 0), rgba(0, 0, 0, 0.8))

(2)公用图片画廊组件拆分


将画廊组件变成一个公用组件src/common/gallary/Gallary.vue


画廊组件:图片轮播+页码显示


使用swiper插件实现轮播功能,使用swiper插件的 paginationType: 'fraction',将分页器样式设置为页码。

‘bullets’  圆点(默认)
‘fraction’  分式 
‘progress’  进度条
custom’ 自定义

创建路径别名,重启服务器。


一开始将gallary显示为隐藏状态,再次显示时计算宽度出现问题,swiper无法正确显示,解决:


data () {
return {
showGallary: true,
swiperOptions: {
pagination: '.swiper-pagination',

// 将分页器样式设置为页码
paginationType: 'fraction',

// swiper监听到此元素或父级元素发生DOM变化时,就会自动刷新一次,解决宽度计算问题。
observeParents:true,
observer:true,

loop:true,
autoplay: false
}
}
}

(3)实现header渐隐渐现效果


methods: {
handleScroll () {
// 获取当前页面的滚动条纵坐标位置
const top = document.documentElement.scrollTop;
// top > 60 时开始逐渐显示header,top > 40 时一直显示header
if (top > 60){
const opacity = top / 140;
opacity > 1 ? 1 : opacity;
this.opacityStyle = {
opacity
};
this.showAbs = false;
}
else{
this.showAbs = true
}
}
},
activated () {
window.addEventListener('scroll', this.handleScroll)
},


(4)对全局事件的解绑(window对象)


// 页面即将被隐藏时执行
deactivated () {
window.removeEventListener('scroll', this.handleScroll)
}

(5)使用递归组件实现详情页列表


(6)使用Ajax获取动态数据


获得动态路由参数(id)并将其传递给后端、


getDetailInfo () {
axios.get('/api/detail.json',{
params: {
id: this.lastRouteId
}
}).then(this.handleGetDetailInfoSucc)
}

(7)组件跳转时页面定位


scrollBehavior (to, from, savedPosition) {
return { x: 0, y: 0 }
}

(8)在项目中加入基础动画


在点击画廊组件时增加渐隐渐现的动画效果


//FadeAnimation.vue

<template>
<transition>
<slot></slot>
</transition>
</template>
<script>
export default{
name: "FadeAnimation"
}
</script>
<style lang="stylus" scoped>
@import '~styles/varibles.styl'
.v-enter, .v-leave-to
opacity: 0
.v-enter-active, .v-leave-active
transition: opacity .5s
</style>

common-gallary 作为插槽插入到fade-animation中:


<!--Banner.vue-->

<fade-animation>
<common-gallary
:imgs="bannerImgs"
v-show="showGallary"
@close="handleGallaryClose"
>

</common-gallary>
</fade-animation>

二、优化



  • 网速慢时图片没有加载出来造成的抖动(使用padding-bottom占位)

  • 重复代码封装:借助stylus提供的mixin对代码进行封装

  • 节流:触摸滑动字母表&搜索框中输入

  • keep-alive

  • 对全局事件解绑


作者:树上结了个小橙子
来源:juejin.cn/post/7222627262399365180
收起阅读 »

快看一看,你是不是这样使用的vscode

web
俗话说:“工欲善其事,必先利其器”。想要高效的编写代码,自然要先熟练的使用一款工具。 vscode设置简体中文 使用国外的工具,头等大事自然是必不可少的汉化。 按快捷键 ‘ctrl+shift+p’,在顶部出现的输入框输入‘configure language...
继续阅读 »

俗话说:“工欲善其事,必先利其器”。想要高效的编写代码,自然要先熟练的使用一款工具。


vscode设置简体中文


使用国外的工具,头等大事自然是必不可少的汉化。


按快捷键 ‘ctrl+shift+p’,在顶部出现的输入框输入‘configure language’,按回车,选择‘zh-cn’。此时,会自动安装中文插件,然后重新打开vscode就可以看到中文界面了。

image.png


vscode实用插件


选择vscode的原因,除了它的轻量之外,自然少不了它丰富的插件库。


1. Auto Rename Tag


自动修改匹配的html标签。在修改标签的时候,是不是需要修改完开始标签之后还需要修改结束标签。安装Auto Rename Tag,以后只需要修改一个标签就可以了,四舍五入就等于减少一半工作量啊。


2. Prettier


代码格式化插件,一键格式化代码,也可以设置保存自动格式化。我会将我的配置放在文章末尾。


3. code runner


可以直接js文件,在控制台输出结果。在写一些小算法的时候再也不用频繁刷新页面打印了。


image.png


4. Turbo Console Log


快捷添加 console.log,一键 注释、启用、删除 所有 console.log。调试js时候大概都会用console.log,每次手敲都很麻烦。


ctrl + alt + l 选中变量之后,生成 console.log
alt + shift + c 注释所有 console.log
alt + shift + u 启用所有 console.log
alt + shift + d 删除所有 console.log

注意,只能注释、启用、删除ctrl + alt + l生成的console.log。如果有小伙伴安装了印象笔记,ctrl + alt + l和印象笔记是冲突的。


5. css-auto-prefix


自动添加 CSS 私有前缀。
比如写完transform样式,会自动添加-webkit-、-moz-等样式。


配置


接下来便是无处不在的配置了,将我的配置贴出来,供大家参考。


文件->首选项->设置->工作台->设置编辑器,将editor的ui改为json,将配置直接粘贴进去


{
"eslint.enable": true,
"eslint.run": "onType",
"eslint.options": {
"extensions": [
".js",
".vue",
".jsx",
".tsx"
]
},
"editor.codeActionsOnSave": {
"source.fixAll.eslint": true
},
"workbench.iconTheme": "material-icon-theme",
"workbench.colorTheme": "Monokai",
"[vue]": {
"editor.defaultFormatter": "esbenp.prettier-vscode"
},
"[json]": {
"editor.defaultFormatter": "esbenp.prettier-vscode"
},
"workbench.settings.editor": "json",
"editor.tabSize": 2,
//失去焦点后自动保存
"files.autoSave": "onFocusChange",
// #值设置为true时,每次保存的时候自动格式化;
"editor.formatOnSave": true,
// 在使用搜索功能时,将这些文件夹/文件排除在外
"search.exclude": {
"**/node_modules": true,
"**/bower_components": true,
"**/target": true,
"**/logs": true,
},
// #让vue中的js按"prettier"格式进行格式化
"vetur.format.defaultFormatter.html": "js-beautify-html",
"vetur.format.defaultFormatter.js": "prettier",
"vetur.format.defaultFormatterOptions": {
"js-beautify-html": {
// #vue组件中html代码格式化样式
"wrap_attributes": "force-aligned", //也可以设置为“auto”,效果会不一样
"wrap_line_length": 200,
"end_with_newline": false,
"semi": false,
"singleQuote": true
},
"prettier": {
"semi": false,
"singleQuote": true
}
},
"[jsonc]": {
"editor.defaultFormatter": "vscode.json-language-features"
}
}

快捷键


熟练的时候快捷键,可以更高效的提升敲代码的效率。我将我常用的快捷键列出,供大家参考。


ctrl + d 选中一个词 鼠标双击也可以
ctrl + f 搜索
ctrl + p 快速打开文件
ctrl + shift + [ 折叠区域代码
ctrl + shift + ] 展开区域代码
ctrl + shift + k 删除一行代码,不过我更喜欢用ctrl+x,因为一只手就可以操作

作者:前端手记
来源:juejin.cn/post/7226248402799345719
收起阅读 »

手写一个类似博客的个人主页 css动画效果多

web
手写一个好看的个人主页 效果图 文字,图片加上各种动画显示,使页面更加美观。然后给头像也加上了一个动画,使头像实现一个一直在上下浮动的效果。媒体组件logo,添加事件hover,置顶会变颜色。按钮添加active激活样式。 最好打开码上掘金看效果图,更明显,...
继续阅读 »

手写一个好看的个人主页


效果图


文字,图片加上各种动画显示,使页面更加美观。然后给头像也加上了一个动画,使头像实现一个一直在上下浮动的效果。媒体组件logo,添加事件hover,置顶会变颜色。按钮添加active激活样式。
image.png
最好打开码上掘金看效果图,更明显,因为显示框问题,这样看布局有点问题。


整体布局


头部


包含一个logo,和一个 导航栏。
logo我这里用了一段文字替代,大家可以自己替换。
header都处于同一行,于是我采用了弹性布局。因为一个左一个右,就可以使用justify-content: space-between;然后logo我给它设置了一个从左往右的动画,时间为1s。导航栏添加了一个从上往下的动画,不过注意的是,我们可以看到每一个导航栏元素是递进往上升的。


实现导航栏元素递进往上升的关键。<a href="#" class="item" style="--i:1">Home</a>我们给每个导航元素都添加了css属性,然后通过这个属性, calc(.2S * var(--i)) 计算每个不同元素的延迟时间,这样我们就可以看到这种延迟效果。
image.png


.header {
position: fixed;
/* 将导航栏固定在页面顶部 */
top: 0;
left: 0;
width: 100%;
padding: 20px 10%;
/* 设置导航栏内边距 */
background: transparent;
/* 设置导航栏背景为透明 */
display: flex;
/* 将导航栏的子元素设置为flex布局 */
justify-content: space-between;
/* 将导航栏子元素分散对齐 */
align-items: center;
/* 将导航栏子元素垂直居中对齐 */
z-index: 100;
/* 将导航栏设置为最上层 */
}

/* 设置导航栏Logo的样式 */
.logo {
font-size: 25px;
/* 设置字体大小 */
color: #fff;
/* 设置字体颜色 */
text-decoration: none;
/* 取消下划线 */
font-weight: 600;
/* 设置字体粗细 */
cursor: default;
/* 设置鼠标样式为默认 */
opacity: 0;
/* 设置初始透明度为0 */
animation: slideRight 1s ease forwards;
/* 设置动画效果 */
}

/* 设置导航栏链接的样式 */
.navbar a {
display: inline-block;
/* 将链接设置为块级元素 */
font-size: 18px;
/* 设置字体大小 */
color: #fff;
/* 设置字体颜色 */
text-decoration: none;
/* 取消下划线 */
font-weight: 500;
/* 设置字体粗细 */
margin-left: 35px;
/* 设置左侧间距 */
opacity: 0;
/* 设置初始透明度为0 */
transition: 0.3s;
/* 设置过渡效果 */
animation: slideTop 1s ease forwards;
/* 设置动画效果 */
animation-delay: calc(.2S * var(--i));
/* 设置动画延迟时间 */
}

/* 设置导航栏链接的鼠标悬停和点击样式 */
.navbar a:hover,
.navbar a:active {
color: #b7b2a9;
/* 设置字体颜色 */
}


<header class="header">
<!-- 网站Logo -->
<a href="#" class="logo">
This is a Logo!
</a>

<!-- 导航栏 -->
<nav class="navbar">
<!-- 导航栏选项1 -->
<a href="#" class="item" style="--i:1">Home</a>
<!-- 导航栏选项2 -->
<a href="#" class="item" style="--i:2">About</a>
<!-- 导航栏选项3 -->
<a href="#" class="item" style="--i:3">Skills</a>
<!-- 导航栏选项4 -->
<a href="#" class="item" style="--i:4">Me</a>
</nav>

</header>

主页部分


主页部分包含文字区域和头像区域。


在文字区域里有一个打印机效果输出文字,可以看我上一篇文章。html手写一个打印机效果-从最基础到学会。然后给每个文字设置不同的动画,比如第一个h1我们让它从上往下,然后第二个h1我们让它从下往上,在他们中间的h1我们让它从左向右出现。在文字区域还有一块是一些media的组件logo,这个我是通过一个js引入的库。然后这些logo跟导航栏元素大致相同,我们也给他们定义了一个css属性,可以让他们相继出现。然后按钮也是添加向上的动画,给定一个延迟时间。


头像区域,我们给头像设置了两个动画,其实动画非常简单,一个其实就是为了显示头像,另一个实现头像上下浮动的效果。


 /* 定义放大的动画 */
@keyframes zoomIn {
0% {
transform: scale(0);
}

100% {
transform: scale(1);
opacity: 1;
}
}

/* 定义图片浮动的动画 */
@keyframes floatImg {
0% {
transform: translateY(0);
}

50% {
transform: translateY(-36px);
}

100% {
transform: translateY(0);
}
}

<link rel="stylesheet" href="https://unpkg.com/boxicons@2.1.4/css/boxicons.min.css">

 <!-- 主页部分 -->

<section class="home">
<!-- 主页内容 -->
<div class="home-content">
<!-- 主页标题 -->
<h3>Hello,It's Me</h3>
<h1>Welcome To Know Me!</h1>
<!-- 主页小标题 -->
<h3>个人介绍
<!-- 小标题下的文本 -->
<span class="text">
</span>
</h3>
<!-- 主页正文 -->
<p>越努力,越幸运!!!Lucky!</p>
<!-- 社交媒体链接 -->
<div class="social-media">
<!-- 社交媒体链接1 -->
<a href="#" style="--i:7"><i class="bx bxl-tiktok"></i></a>
<!-- 社交媒体链接2 -->
<a href="#" style="--i:8"><i class="bx bxl-facebook-circle"></i></a>
<!-- 社交媒体链接3 -->
<a href="#" style="--i:9"><i class="bx bxl-google"></i></a>
<!-- 社交媒体链接4 -->
<a href="#" style="--i:10"><i class="bx bxl-linkedin-square"></i></a>
</div>
<!-- 主页按钮 -->
<a href="#" class="btn">Learn More</a>
</div>
<!-- 主页图片 -->
<div class="home-img">
<img src="https://img.wxcha.com/m00/54/ed/69d26be4a4ac700e27c2d9cf85472b8c.jpg" alt="">
</div>
</section>

整体代码


动画的代码


  /*动画*/
@keyframes blink {

from,
to {
border-color: transparent;
/* 透明边框颜色 */
}

50% {
border-color: white;
/* 白色边框颜色 */
}
}

/* 定义向右滑动的动画 */
@keyframes slideRight {
0% {
transform: translateX(-100px);
}

100% {
transform: translateX(0px);
opacity: 1;
}
}

/* 定义向左滑动的动画 */
@keyframes slideLeft {
0% {
transform: translateX(100px);
}

100% {
transform: translateX(0px);
opacity: 1;
}
}

/* 定义向上滑动的动画 */
@keyframes slideTop {
0% {
transform: translateY(100px);
}

100% {
transform: translateY(0px);
opacity: 1;
}
}

/* 定义向下滑动的动画 */
@keyframes slideBottom {
0% {
transform: translateY(-100px);
}

100% {
transform: translateY(0px);
opacity: 1;
}
}

/* 定义放大的动画 */
@keyframes zoomIn {
0% {
transform: scale(0);
}

100% {
transform: scale(1);
opacity: 1;
}
}

/* 定义图片浮动的动画 */
@keyframes floatImg {
0% {
transform: translateY(0);
}

50% {
transform: translateY(-36px);
}

100% {
transform: translateY(0);
}
}

源码


链接自取
掘金/个人页面 · Mr-W-Y-P/Html-css-js-demo - 码云 - 开源中国 (gitee.com)


作者:Mr-Wang-Y-P
来源:juejin.cn/post/7225444782331592764
收起阅读 »

css水滴登录界面

web
前言 今天我们来分享一款非常有趣的登录界面,它使用HTML和CSS制作,具有动态的水波纹效果,让用户在登录时感受到了一股清凉之感。 基本html框架 <!DOCTYPE html> <html lang="en"> <head&...
继续阅读 »

前言


今天我们来分享一款非常有趣的登录界面,它使用HTML和CSS制作,具有动态的水波纹效果,让用户在登录时感受到了一股清凉之感。


基本html框架


<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Document</title>
<link rel="stylesheet" href="water.css">
<link rel="stylesheet" href="form.css">
</head>

<body>
<div class="main">
<form>
<p>用户名<br />
<input type="text" class="textinput" placeholder="请输入用户名" />
</p>
<p>密码<br />
<input type="password" class="textinput" placeholder="请输入密码" />
</p>
<p>
<input id="remember" type="checkbox" /><label for="smtxt">记住密码</label>
</p>
<p>
<input type="submit" value="登录" />
</p>
<p class="txt">还没有账户?<a href="#">注册</a></p>
</form>
</div>
</body>
</html>

首先,我们来看HTML代码。这个登录界面包含一个表单,用户需要在表单中输入用户名和密码。我们使用p标签创建输入框,并设置class属性以便后续的CSS样式设置。此外,我们还在表单中添加了一个“记住密码”的复选框和一个登录按钮,同时还有一个注册链接。


表单样式


form{            
opacity: 0.8;
text-align: center;
padding: 0px 100px;
border-radius: 10px;
margin: 120px auto;
}

p {
-webkit-text-stroke: 1px #8e87c3;
}

对表单整体进行样式定义,使其位于水滴内部,p标签内文镂空。


.textinput{
height: 40px;
font-size: 15px;
width: 100px;
padding: 0 35px;
border: none;
background: rgba(250, 249, 249, 0.532);
box-shadow: inset 4px 4px 10px rgba(160, 162, 158, 0.814), 4px 4px 10px rgba(117, 117, 117, 0.3), 15px 15px 30px rgba(72, 70, 70, 0.193), inset -2px -2px 10px rgba(255, 254, 254, 0.873);
border-radius: 50px;
-webkit-text-stroke: 0px;
color: saddlebrown;
outline-style: none;
}

对输入框进行样式定义,取消镂空字体样式,取消轮廓线,设置阴影实现水滴一般效果。


input[type="submit"]{
width: 110px;
height: 40px;
text-align: center;
outline-style: none;
border-style: none;
border-radius: 50px;
background: rgb(31, 209, 218);
-webkit-text-stroke: 0px;
box-shadow: inset 4px 4px 10px rgba(160, 162, 158, 0.814), 4px 4px 10px rgba(117, 117, 117, 0.3), 15px 15px 30px rgba(72, 70, 70, 0.193), inset -2px -2px 10px rgba(255, 254, 254, 0.873);
}

我们使用了input[type="submit"] 选择器来选中提交按钮,并设置了按钮的大小、文本对齐方式、圆角和背景等样式,去除了轮廓线。同样采用了阴影来设置按钮,使其具有气泡一般的感觉,并设置背景色。


input[type="submit"]:hover {
background-color: rgb(31, 218, 78);
}

这段代码是用来为按钮添加鼠标悬停效果的。我们使用了input[type="submit"]:hover选择器来选中鼠标悬停在按钮上时的状态,并设置了背景颜色。当用户悬停在按钮上时,按钮的背景颜色会改变,非常引人注目。


a {
text-decoration: none;
color: rgba(236, 20, 20, 0.433);
-webkit-text-stroke: 1px;
}

a:hover {
text-decoration: underline;
}

提交按钮底部注册文字样式,采用镂空字体样式,鼠标移至该元素上方时,添加下划线。


* {
margin: 0;
padding: 0;
}
body {
background: skyblue;
}

这段代码是对所有元素的外边距和内边距进行清零,以便更好地控制元素的位置和大小,设置了整个页面的背景颜色为天蓝色。


.main {
position: absolute;
left: 50%;
top: 50%;
transform: translate(-50%, -50%);
width: 400px;
height: 400px;
box-sizing: border-box;
border-radius: 50%;
background: transparent;
box-shadow: inset 15px 10px 40px rgba(158, 158, 158, 0.303), 10px 10px 20px rgba(117, 117, 117, 0.3), 15px 15px 30px rgba(72, 70, 70, 0.193), inset -10px -10px 20px rgba(233, 229, 229, 0.873);
animation: move 6s linear infinite;
}

这段代码采用绝对定位,以便更好地控制它的位置。left: 50%; top: 50%; 将元素的左上角定位在页面的中心位置。通过transform属性将元素向左上角移动50%,以便让元素的中心位置与页面中心位置重合。设置元素的宽度和高度为400像素。background: transparent; 将元素的背景设置为透明色。box-shadow: inset 15px 10px 40px rgba(158, 158, 158, 0.303), 10px 10px 20px rgba(117, 117, 117, 0.3), 15px 15px 30px rgba(72, 70, 70, 0.193), inset -10px -10px 20px rgba(233, 229, 229, 0.873); 设置元素的阴影效果,包括内阴影和外阴影。animation: move 6s linear infinite; 为元素添加动画效果,其中move 是动画名称,6s是动画时长,linear是动画速度曲线,infinite是动画循环次数。


.main::after {
position: absolute;
content: "";
width: 40px;
height: 40px;
background: rgba(254, 254, 254, 0.667);
left: 80px;
top: 80px;
border-radius: 50%;
animation: move2 6s linear infinite;
filter:blur(1px);
}

.main::before {
position: absolute;
content: "";
width: 20px;
height: 20px;
background: rgba(255, 255, 255, 0.5);
left: 130px;
top: 70px;
border-radius: 50%;
animation: move3 6s linear infinite;
filter:blur(1px);
}

这段代码是对两个小球进行样式定义,将伪元素的定位方式设置为绝对定位,以便更好地控制它的位置,设置伪元素的宽度和高度一个为20px,一个为40px。设置伪元素的背景颜色为半透明白色。left,top 设置伪元素的左上角定位在主体元素的中心位置,设置伪元素的边框半径为50%,以便将其设置为圆形。animation: move2 6slinear infinite; 为伪元素添加动画效果,其中 move2 是动画名称,6s 是动画时长,linear 是动画速度曲线,infinite 是动画循环次数,另一个伪元素同理。
接下来是动画定义:


@keyframes move {
50% {
border-radius: 42% 58% 49% 51% / 52% 36% 64% 48% ;
}
75% {
border-radius: 52% 48% 49% 51% / 43% 49% 51% 57% ;
}
25% {
border-radius: 52% 48% 59% 41% / 43% 49% 51% 57% ;
}
}

@keyframes move2 {
25% {
left: 80px;
top: 110px;
}
50% {
left: 50px;
top: 80px;
}
75% {
left: 80px;
top: 120px;
}
}

@keyframes move3 {
25% {
left: 100px;
top: 90px;
}
50% {
left: 110px;
top: 75px;
}
75% {
left: 130px;
top: 100px;
}
}

这段代码定义了三个不同的动画,分别是move、move2和move3。move动画,它控制了元素的边框半径在不同时间点的变化。在这个动画中,元素的边框半径分别在25%、50%和75%的时间点进行了变化。move2move3动画,控制了一个伪元素的位置在不同时间点的变化。在这个动画中,伪元素的位置分别在25%、50%和75%的时间点进行了变化。


结语


以上便是全部代码,喜欢的可以自取,样式不

作者:codePanda
来源:juejin.cn/post/7225623397144199228
好看可以自行更改😜。

收起阅读 »

可视化大屏:vue-autofit 一行搞定自适应

web
可视化大屏适配/自适应现状 可视化大屏的适配是一个老生常谈的话题了,现在其实不乏一些大佬开源的自适应插件、工具但是我为什么还要重复造轮子呢?因为目前市面上适配工具每一个都无法做到完美的效果,做出来的东西都差不多,最终实现效果都逃不出白边的手掌心,可以解决白边问...
继续阅读 »

可视化大屏适配/自适应现状


可视化大屏的适配是一个老生常谈的话题了,现在其实不乏一些大佬开源的自适应插件、工具但是我为什么还要重复造轮子呢?因为目前市面上适配工具每一个都无法做到完美的效果,做出来的东西都差不多,最终实现效果都逃不出白边的手掌心,可以解决白边问题的,要么太过于复杂,要么会影响dom结构。


三大常用方式




  1. vw/vh方案



    1. 概述:按照设计稿的尺寸,将px按比例计算转为vwvh

    2. 优点:可以动态计算图表的宽高,字体等,灵活性较高,当屏幕比例跟 ui 稿不一致时,不会出现两边留白情况

    3. 缺点:每个图表都需要单独做字体、间距、位移的适配,比较麻烦




  2. scale方案



    1. 概述:也是目前效果最好的一个方案

    2. 优点:代码量少,适配简单 、一次处理后不需要在各个图表中再去单独适配.

    3. 缺点:留白,据说有事件热区偏移,但是我目前没有发现有这个问题,即使是地图也没有




  3. rem + vw vh方案



    1. 概述:这名字一听就麻烦,具体方法为获得 rem 的基准值 ,动态的计算html根元素的font-size ,图表中通过 vw vh 动态计算字体、间距、位移等

    2. 优点:布局的自适应代码量少,适配简单

    3. 缺点:留白,有时图表需要单独适配字体




基于此背景,我决定要造一个简单又好用的轮子。


解决留白问题


留白问题是在使用scale时才会出现,而其他方式实现起来又复杂,效果也不算太理想,总会破坏掉原有的结构,可能使元素挤在一起,所以我们还是选择使用scale方案,不过这次要做出一点小小的改变。


常用分辨率


首先来看一下我的拯救者的分辨率:


image-20230420141240837 它可以代表从1920往下的分辨率


我们可以发现,比例分别是:1.77、1.6、1.77、1.6、1.33... 总之,没有特别夸张的宽高比。


计算补齐白边所需的px


只要没有特别夸张的宽高比,就不会出现特别宽或者特别高的白边,那么我们能不能直接将元素宽高补过去?也就是说,当屏幕右侧有白边时,我们就让宽度多出一个白边的px,当屏幕下方有白边时,我们就让高度多出一个白边的px。


很喜欢CSGO玩家的一句话:"啊?"


先想一下,如果此时按宽度比例缩放,会在下方留下白边,所以设置一下它的高度,设置多少呢?比如 scale==0.8 ,也就是说整个#app缩小了0.8倍,我们需要将高扩大多少倍才可以回到原来的大小呢?


QQ录屏20230420144111


emmm.....


算数我最不在行了,启动高材生


image-20230420143742913


原来是八分之十,我vue烧了。


当浏览器窗口比设计稿大或者小的时候,就应该触发缩放,但是比例不一定,如果按照scale等比缩放时,宽度从1920缩小0.8倍也就是1536,而高度缩小0.8也就是743,如果此时浏览器高度过高,那么就会出现下方的白边,根据高材生所说的,缩小0.8后只需要放大八分之十就可以变回原大小,所以以现在的高度743*1.25=928,使宽度=928px就可以完全充满白边!


真的是这样吗?感觉哪里不对劲...


是浏览器高度!我忽略了浏览器高度,我可以直接使用浏览器高度乘以1.25然后再缩放达0.8!就是 1 !


也就是说 clientHeight / scale 就等于我们需要的高度!


我们用代码试一试


function keepFit(designWidth, designHeight, renderDom) {
 let clientHeight = document.documentElement.clientHeight;
 let clientWidth = document.documentElement.clientWidth;
 let scale = 1;
 if (clientWidth / clientHeight < designWidth / designHeight) {
   scale = (clientWidth / designWidth)
   document.querySelector(renderDom).style.height = `${clientHeight / scale}px`;
} else {
   scale = (clientHeight / designHeight)
   document.querySelector(renderDom).style.width = `${clientWidth / scale}px`;
}
 document.querySelector(renderDom).style.transform = `scale(${scale})`;
}

上面的代码可能看起来乱糟糟的,我来解释一下:


参数分别是:设计稿的宽高和你要适配的元素,在vue中可以直接传#app。


下面的if判断的是宽度固定还是高度固定,当屏幕宽高比小于设计宽高比时,


我们把高度写成 clientHeight / scale ,宽度也是同理。


最终效果


将这段代码放到App.vue的mounted运行一下


autofit


如上图所示:我们成功了,我们仅用了1 2 3 4....这么几行代码,就做到了足以媲美复杂写法的自适应!


我把这些东西封装了一个npm包:vue-autofit ,开箱即用,欢迎下载!


亲手打造集成工具:vue-autofit


这是一款可以使你的项目一键自适应的工具 github源码👉go



  • 从npm下载


npm i vue-autofit


  • 引入


import autofit from 'vue-autofit'


  • 快速开始


autofit.init()


默认参数为1920*929(即去掉浏览器头的1080), 直接在大屏启动时调用即可




  • 使用


export default {  
 mounted() {
 autofit.init({
       designHeight: 1080,
       designWidth: 1920,
       renderDom:"#app",
       resize: true
  })
},
}


以上使用的是默认参数,可根据实际情况调整,参数分别为


   * - renderDom(可选):渲染的dom,默认是 "#app",必须使用id选择器 
  * - designWidth(可选):设计稿的宽度,默认是 1920
  * - designHeight(可选):设计稿的高度,默认是 929 ,如果项目以全屏展示,则可以设置为1080
  * - resize(可选):是否监听resize事件,默认是 true


结语


诺克萨斯即将崛起


作者:德莱厄斯
来源:juejin.cn/post/7224015103481118757
收起阅读 »

上手 Vue 新的状态管理 Pinia,一篇文章就够了

web
Vuex 作为一个老牌 Vue 状态管理库,大家都很熟悉了 Pinia 是 Vue.js 团队成员专门为 Vue 开发的一个全新的状态管理库,并且已经被纳入官方 github 为什么有 Vuex 了还要再开发一个 Pinia ? 先来一张图,看下当时对于 Vu...
继续阅读 »

Vuex 作为一个老牌 Vue 状态管理库,大家都很熟悉了


Pinia 是 Vue.js 团队成员专门为 Vue 开发的一个全新的状态管理库,并且已经被纳入官方 github


为什么有 Vuex 了还要再开发一个 Pinia ?


先来一张图,看下当时对于 Vuex5 的提案,就是下一代 Vuex5 应该是什么样子的


微信图片_20220314212501.png


Pinia 就是完整的符合了他当时 Vuex5 提案所提到的功能点,所以可以说 Pinia 就是 Vuex5 也不为过,因为它的作者就是官方的开发人员,并且已经被官方接管了,只是目前 Vuex 和 Pinia 还是两个独立的仓库,以后可能会合并,也可能独立发展,只是官方肯定推荐的是 Pinia


因为在 Vue3 中使用 Vuex 的话需要使用 Vuex4,还只能作为一个过渡的选择,存在很大缺陷,所以在 Componsition API 诞生之后,也就设计了全新的状态管理 Pinia


Pinia 和 Vuex


VuexStateGettesMutations(同步)、Actions(异步)


PiniaStateGettesActions(同步异步都支持)


Vuex 当前最新版是 4.x



  • Vuex4 用于 Vue3

  • Vuex3 用于 Vue2


Pinia 当前最新版是 2.x



  • 即支持 Vue2 也支持 Vue3


就目前而言 Pinia 比 Vuex 好太多了,解决了 Vuex 的很多问题,所以笔者也非常建议直接使用 Pinia,尤其是 TypeScript 的项目


Pinia 核心特性



  • Pinia 没有 Mutations

  • Actions 支持同步和异步

  • 没有模块的嵌套结构

    • Pinia 通过设计提供扁平结构,就是说每个 store 都是互相独立的,谁也不属于谁,也就是扁平化了,更好的代码分割且没有命名空间。当然你也可以通过在一个模块中导入另一个模块来隐式嵌套 store,甚至可以拥有 store 的循环依赖关系



  • 更好的 TypeScript 支持

    • 不需要再创建自定义的复杂包装器来支持 TypeScript 所有内容都类型化,并且 API 的设计方式也尽可能的使用 TS 类型推断



  • 不需要注入、导入函数、调用它们,享受自动补全,让我们开发更加方便

  • 无需手动添加 store,它的模块默认情况下创建就自动注册的

  • Vue2 和 Vue3 都支持

    • 除了初始化安装和SSR配置之外,两者使用上的API都是相同的



  • 支持 Vue DevTools

    • 跟踪 actions, mutations 的时间线

    • 在使用了模块的组件中就可以观察到模块本身

    • 支持 time-travel 更容易调试

    • 在 Vue2 中 Pinia 会使用 Vuex 的所有接口,所以它俩不能一起使用

    • 但是针对 Vue3 的调试工具支持还不够完美,比如还没有 time-travel 功能



  • 模块热更新

    • 无需重新加载页面就可以修改模块

    • 热更新的时候会保持任何现有状态



  • 支持使用插件扩展 Pinia 功能

  • 支持服务端渲染


Pinia 使用


Vue3 + TypeScript 为例


安装


npm install pinia

main.ts 初始化配置


import { createPinia } from 'pinia'
createApp(App).use(createPinia()).mount('#app')

在 store 目录下创建一个 user.ts 为例,我们先定义并导出一个名为 user 的模块


import { defineStore } from 'pinia'
export const userStore = defineStore('user', {
state: () => {
return {
count: 1,
arr: []
}
},
getters: { ... },
actions: { ... }
})

defineStore 接收两个参数


第一个参数就是模块的名称,必须是唯一的,多个模块不能重名,Pinia 会把所有的模块都挂载到根容器上

第二个参数是一个对象,里面的选项和 Vuex 差不多



  • 其中 state 用来存储全局状态,它必须是箭头函数,为了在服务端渲染的时候避免交叉请求导致的数据状态污染所以只能是函数,而必须用箭头函数则为了更好的 TS 类型推导

  • getters 就是用来封装计算属性,它有缓存的功能

  • actions 就是用来封装业务逻辑,修改 state


访问 state


比如我们要在页面中访问 state 里的属性 count


由于 defineStore 会返回一个函数,所以要先调用拿到数据对象,然后就可以在模板中直接使用了


如下这样通过 store.xxx 使用,是具备响应式的


<template>
<div>{{ store.count }}</div>
</template>
<script lang="ts" setup>
import { userStore } from '../store'
const store = userStore()
// 解构
// const { count } = userStore()
</script>


比如像注释中的解构出来使用,也可以用,只是这样拿到的数据不是响应式的,如果要解构还保持响应式就要用到一个方法 storeToRefs(),示例如下


<template>
<div>{{ count }}</div>
</template>
<script lang="ts" setup>
import { storeToRefs } from 'pinia'
import { userStore } from '../store'
const { count } = storeToRefs(userStore())
</script>


原因就是 Pinia 其实是把 state 数据都做了 reactive 处理,和 Vue3 的 reactive 同理,解构出来的也不是响应式,所以需要再做 ref 响应式代理


getters


这个和 Vuex 的 getters 一样,也有缓存功能。如下在页面中多次使用,第一次会调用 getters,数据没有改变的情况下之后会读取缓存


<template>
<div>{{ myCount }}</div>
<div>{{ myCount }}</div>
<div>{{ myCount }}</div>
</template>

注意两种方法的区别,写在注释里了


getters: {
// 方法一,接收一个可选参数 state
myCount(state){
console.log('调用了') // 页面中使用了三次,这里只会执行一次,然后缓存起来了
return state.count + 1
},
// 方法二,不传参数,使用 this
// 但是必须指定函数返回值的类型,否则类型推导不出来
myCount(): number{
return this.count + 1
}
}

更新和 actions


更新 state 里的数据有四种方法,我们先看三种简单的更新,说明都写在注释里了


<template>
<div>{{ user_store.count }}</div>
<button @click="handleClick">按钮</button>
</template>
<script lang="ts" setup>
import { userStore } from '../store'
const user_store = userStore()
const handleClick = () => {
// 方法一
user_store.count++

// 方法二,需要修改多个数据,建议用 $patch 批量更新,传入一个对象
user_store.$patch({
count: user_store.count1++,
// arr: user_store.arr.push(1) // 错误
arr: [ ...user_store.arr, 1 ] // 可以,但是还得把整个数组都拿出来解构,就没必要
})

// 使用 $patch 性能更优,因为多个数据更新只会更新一次视图

// 方法三,还是$patch,传入函数,第一个参数就是 state
user_store.$patch( state => {
state.count++
state.arr.push(1)
})
}
</script>


第四种方法就是当逻辑比较多或者请求的时候,我们就可以封装到示例中 store/user.ts 里的 actions 里


可以传参数,也可以通过 this.xx 可以直接获取到 state 里的数据,需要注意的是不能用箭头函数定义 actions,不然就会绑定外部的 this 了


actions: {
changeState(num: number){ // 不能用箭头函数
this.count += num
}
}

调用


const handleClick = () => {
user_store.changeState(1)
}

支持 VueDevtools


打开开发者工具的 Vue Devtools 就会发现 Pinia,而且可以手动修改数据调试,非常方便


image.png


模拟调用接口


示例:


我们先定义示例接口 api/user.ts


// 接口数据类型
export interface userListType{
id: number
name: string
age: number
}
// 模拟请求接口返回的数据
const userList = [
{ id: 1, name: '张三', age: 18 },
{ id: 2, name: '李四', age: 19 },
]
// 封装模拟异步效果的定时器
async function wait(delay: number){
return new Promise((resolve) => setTimeout(resolve, delay))
}
// 接口
export const getUserList = async () => {
await wait(100) // 延迟100毫秒返回
return userList
}

然后在 store/user.ts 里的 actions 封装调用接口


import { defineStore } from 'pinia'
import { getUserList, userListType } from '../api/user'
export const userStore = defineStore('user', {
state: () => {
return {
// 用户列表
list: [] as userListType // 类型转换成 userListType
}
},
actions: {
async loadUserList(){
const list = await getUserList()
this.list = list
}
}
})

页面中调用 actions 发起请求


<template>
<ul>
<li v-for="item in user_store.list"> ... </li>
</ul>

</template>
<script lang="ts" setup>
import { userStore } from '../store'
const user_store = userStore()
user_store.loadUserList() // 加载所有数据
</script>


跨模块修改数据


在一个模块的 actions 里需要修改另一个模块的 state 数据


示例:比如在 chat 模块里修改 user 模块里某个用户的名称


// chat.ts
import { defineStore } from 'pinia'
import { userStore } from './user'
export const chatStore = defineStore('chat', {
actions: {
someMethod(userItem){
userItem.name = '新的名字'
const user_store = userStore()
user_store.updateUserName(userItem)
}
}
})

user 模块里


// user.ts
import { defineStore } from 'pinia'
export const userStore = defineStore('user', {
state: () => {
return {
list: []
}
},
actions: {
updateUserName(userItem){
const user = this.list.find(item => item.id === userItem.id)
if(user){
user.name = userItem.name
}
}
}
})

结语


如果本文对你有一点点帮助,点个赞支持一下吧,你的每一个【赞】都是我创作的最大动力,感谢支持 ^_^


更多前端文章,或者加入前端交流群,欢迎关注公众号【沐华说技术】,大家一起共同交流和进步呀





往期精彩


【保姆级】Vue3 开发文档


Vue3的8种和Vue2的12种组件通信,值得收藏


作者:沐华
来源:juejin.cn/post/7075491793642455077
收起阅读 »

怎么实现微信扫码登录

web
最近在给企业健康管理系统做一个微信扫码登录的功能,借此机会总结下微信登录这个技术点。 网站应用微信登录是基于 OAuth2.0 协议标准构建的。OAuth 协议规范了五种授权模式,Authorization Code、PKCE、Client CreDentia...
继续阅读 »

最近在给企业健康管理系统做一个微信扫码登录的功能,借此机会总结下微信登录这个技术点。


网站应用微信登录是基于 OAuth2.0 协议标准构建的。OAuth 协议规范了五种授权模式,Authorization Code、PKCE、Client CreDentials、Device Code 和 Refresh Token。微信目前只支持 authorization_code 模式。


微信网站应用接入基础知识


第一步需要先到微信开放平台注册一个开发者账号,并创建一个微信登录网站应用,然后获得AppIDAppSecret


微信的authorization_code模式:



  1. 发起微信授权登录请求



// 请求格式
https://open.weixin.qq.com/connect/qrconnect?appid=APPID&redirect_uri=REDIRECT_URI&response_type=code&scope=SCOPE&state=STATE#wechat_redirect



  1. 用户扫码授权之后,微信会重定向到回调地址并且给予一个临时票据code;

  2. 后端拿codeAppIDAppSecret通过 API 换取access_token;

  3. 通过access_token进行接口调用,换取用户基本信息

  4. 根据用户信息中的 openId 查询是否已经和系统用户绑定


流程图:


微信官方


关于 state 参数:


state参数: state 参数会在用户授权成功后和code一起携带给 redirect URL。主要用来做 CSRF 防范。



redirect_url?code=CODE&state=STATE

关于 code:
Code 的超时时间为 10 分钟,一个 code 只能成功换取一个 access_token 即失效。


关于展示形式


微信登录有两种展示形式,一种是弹窗打开登录二维码,另一种是将二维码嵌套在自己网页内


我们的设计


交互流程


login_flow.png


前端工作流程:


1、二维码展示,请求/wechat/qrcode 地址获取二维码地址,返回的参数有 state 字段(重要)。


Note:后端生成一个 uuid state,并存储在 Redis 中用来检测用户的扫码状态


2、在当前二维码页面轮询/wechat/qrcode/status/{state} 接口,判断是否已授权、未绑定、已绑定三种状态。


1)未授权,继续轮询

2)已授权已绑定,根据/wechat/qrcode/status/{state} 接口返回的租户、登录凭证,调用登录接口/login/wechat。

3)已授权未绑定,进去用户绑定微信流程

> 用户绑定微信流程
请求/wechat/bind/sms/send 接口,发送用户绑定微信的验证码
请求/wechat/bind 接口,绑定用户。
根据/wechat/bind 接口返回的租户、凭证信息,调用登录接口/login/wechat。

参考文档


网站应用微信登录开发指南


博客原文


iloveu.xyz/2023/04/25/…


作者:贾克森
来源:juejin.cn/post/7225867003720974373
收起阅读 »

微信小程序背景音频开发

web
最近又新开发了一款听书类的小程序,现在一阶段已基本完工。代码已开源,链接在文章结尾。欢迎star。 本期给大家讲解一下关于背景音频开发的一些基本业务场景和踩坑。 1.需求拆解 先来看一张图: 从图中可以看到,基本的业务包含以下几个部分 播放 暂停 切换上一...
继续阅读 »

最近又新开发了一款听书类的小程序,现在一阶段已基本完工。代码已开源,链接在文章结尾。欢迎star。


本期给大家讲解一下关于背景音频开发的一些基本业务场景和踩坑。


1.需求拆解


先来看一张图:


image.png
从图中可以看到,基本的业务包含以下几个部分



  1. 播放

  2. 暂停

  3. 切换上一个音频

  4. 切换下一个音频

  5. 拖动进度条改变音频进度

  6. 音频进度时间

  7. 音频总时间

  8. 在音频列表切换任意的音频


还有一个需求就是在小程序退出以后,还会播放:


image.png
在上图里看到,当背景音频播放的时候,会出现上方这个小图标:


image.png
同样的,在手机的通知栏里面,长这样子:
image.png


接下来我们动手实现一下整个功能。


2. 技术分析


要想实现背景音频,我们需要使用微信小程序提供的一个API:getBackgroundAudioManager(),因为我这里使用的UNI开发的,所以直接贴的是UNI的文档了。具体方法参数可以查看文档。


这里注意以下几个点:



  • ios App平台,背景播放需在manifest.json -> app-plus -> distribute -> ios 节点添加 "UIBackgroundModes":["audio"] 才能保证音乐可以后台播放(打包成ipa生效)

  • 小程序平台,需在manifest.json 对应的小程序节点下,填写"requiredBackgroundModes": ["audio"]。发布小程序时平台会审核。

  • 在page.json中添加"UIBackgroundModes":["audio"]

  • 配置完以后,重新编译一下项目。


3. 功能实现


3.1 播放slider


1.获取音频数据


在进入播放音频页面的时候,默认获取一下第一个需要播放的音频。我这里是是根据音频的id去获取音频的详情信息:


/**
* @description: 获取专辑声音详情信息
* @returns {*}
*/

const getTrackInfo = async (trackId: number) => {
try {
const res = await albumsService.getTrackInfo(trackId)
trackInfo.value = res.data
audios.trackId = res.data?.id as number;
createBgAudioManager()
} catch (error) {
console.log(error)
}
}
onLoad((options) => {
const { trackId } = options
audios.trackId = trackId
getTrackInfo(trackId)
})

getTrackInfo返回的的数据里面长这样的:


image.png
播放音频需要设置红色框标识的字段。


2.创建音频


请求成功,拿到音频详情数据,就需要创建背景音频。


// 初始化背景音频控件
const bgAudioManager = uni.getBackgroundAudioManager();

/**
* @description: 修改音频地址
* @returns {*}
*/

const createBgAudioManager = () => {
// 音频测试地址
// innerAudioContext.src = 'https://bjetxgzv.cdn.bspapp.com/VKCEYUGU-hello-uniapp/2cc220e0-c27a-11ea-9dfb-6da8e309e0d8.mp3';
if (bgAudioManager) {

// 若原先的音频未暂停,则先暂停
if (!bgAudioManager.paused) {
// stop和pause是不一样的,stop直接停止播放,然后从头开始
bgAudioManager.stop();
}
bgAudioManager.title = trackInfo.value?.trackTitle;
bgAudioManager.coverImgUrl = trackInfo.value?.coverUrl
// 设置了src以后会自动播放
bgAudioManager.src = trackInfo.value?.mediaUrl;
// bgAudioManager.autoplay = true;
initAudio(bgAudioManager)
}
}


这里注意一下,title是必须要设置的。不然音频不播放。当设置了src以后,音频会自动进行播放,无需设置autoPlay。



3.获取播放进度和音频总长度


在上面的函数里面,有个initAudio函数。


/**
* @description: 初始化音频相关的方法
* @param {*} ctx
* @returns {*}
*/

const initAudio = (ctx: any) => {
ctx.onTimeUpdate((e) => {
// 当拖动进度条的时候不需要更新进度,使用seek方法
if(!sliders.isDraging) {
// 获取当前进度
const currentTime:number = ctx.currentTime
// 跟新音频进度和slider进度
if (currentTime) {
sliders.progressTime = ctx.currentTime
audios.currentTime = formatTime(currentTime);
}
}
})
ctx.onCanplay(() => {
setTimeout(() => {
console.log('音频长度', bgAudioManager.duration);
// 音频长度,时分秒格式
const duration = bgAudioManager.duration
audios.duration = formatTime(duration);
// 进度条长度=音频长度
sliders.max = duration
}, 300)
})
ctx.onPlay(() => {
audios.playStatus = true
})
ctx.onPause(() => {
audios.playStatus = false
})
ctx.onEnded((e) => {
// 播放结束自动切换到下一首歌
nextAudio()
})
}

onCanplay中,我们可以获取音频的总长度,注意这里的setTimeout必须加,不然获取不到duration。这里需要把秒格式和时分秒的格式都保存下来。


onTimeUpdate中,我们可以获取到当前音频播放的进度。然后实时更新进度条。


接下来就是进度条的实现了。


这里我用的是uni内置组件中的slider组件。


<slider
step="1"
activeColor="#f86442"
block-color="#fff"
block-size="10"
:min="0"
:max="sliders.max"
:value="sliders.progressTime"
@change="sliderChange"
@touchstart="handleSliderMoveStart "
@touchend="handleSliderMoveEnd"
/>


max必须设置,也就是音频的总长度。
value值是当前音频播放的进度。


4.拖动进度条


当拖动进度条的时候,触发sliderChange事件,改变音频的进度。



/**
* @description: 进度条改变事件
* @returns {*}
*/

const sliderChange = (e) => {
console.log(e);
// 拖动slider的值
const position = e.detail.value
seekAudio(position)
}
/**
* 音频跳转
*/

const seekAudio = (position: number) => {
bgAudioManager.seek(position)
// 修改当前进度
audios.currentTime = formatTime(position)
sliders.progressTime = position
}

这里通过seek方法来设置进度的跳转。


当拖动进度条的时候,在onTimeUpdate中也在修改进度。两个之间会打架。所以这里我们在onTimeUpdate中使用isDraging字段来控制。当鼠标按下和抬起的时候来控制isDraging的值,不让onTimeUpdate修改进度。


/**
* @description: 开始拖动进度条事件
* @returns {*}
*/

const handleSliderMoveStart = () => {
sliders.isDraging = true
}
/**
* @description: 结束拖动进度条时间
* @returns {*}
*/

const handleSliderMoveEnd = () => {
sliders.isDraging = false
}

// 此逻辑在前面的代码有了
ctx.onTimeUpdate((e) => {
// 当拖动进度条的时候不需要更新进度,使用seek方法
if(!sliders.isDraging) {
...
}
})

3.2 播放暂停


播放和暂停就非常简单了。


通过playStatus字段来控制播放和暂停按钮的样式切换即可。


其次是事件:


/**
* @description: 暂停音频
* @returns {*}
*/

const pauseAudio = () => {
bgAudioManager.pause() // 停止
}

/**
* @description: 播放音频
* @returns {*}
*/

const playAudio = () => {
bgAudioManager.play() // 播放
}

// 在钩子函数监听

ctx.onPlay(() => {
audios.playStatus = true
})
ctx.onPause(() => {
audios.playStatus = false
})

3.3 音频列表渲染和切换


image.png


这个列表怎么渲染的我就不讲了。这里还有个下拉刷新和上拉加载更多的功能。


当点击某个音频,获取对应的id,然后请求接口获取对应的音频详情。接口和流程跟之前的一样。唯一注意的是,当我们点击的是正在播放的一个音频的话,啥也不要做。还有一个注意的点,当切换音频的时候需要先暂停,然后再设置src和别的属性。



const createBgAudioManager = () => {

if (bgAudioManager) {

// 若原先的音频未暂停,则先暂停
if (!bgAudioManager.paused) {
// stop和pause是不一样的,stop直接停止播放,然后从头开始
bgAudioManager.stop();
}
bgAudioManager.title = trackInfo.value?.trackTitle;
bgAudioManager.coverImgUrl = trackInfo.value?.coverUrl
// 设置了src以后会自动播放
bgAudioManager.src = trackInfo.value?.mediaUrl;
// bgAudioManager.autoplay = true;
initAudio(bgAudioManager)
}
}

注意这里的暂停不是pause,是stop。


3.4 上一个下一个切换


当切换上一个和下一个音频的时候,逻辑也是需要票拿到对应的id,然后请求音频详细数据。


/**
* @description: 切换上一首音频
* @returns {*}
*/

const prevAudio = () => {
// 判断是不是第一首,是则提示
const firstId = audioList.value[0]?.trackId
if (firstId === audios.trackId) {
uni.showToast({
title : "当前已经是第一首了",
icon : "none"
})
return;
}
// 获取上一首的id
// 从播放列表寻找
let id = 0;
audioList.value.forEach((item, index) => {
if (item.trackId === audios.trackId) {
id = audioList.value[index - 1]?.trackId
}
})

getTrackInfo(id)
}
/**
* @description: 切换下一首音频
* @returns {*}
*/

const nextAudio = () => {
// 判断是不是最后一首。是则提示
const len = audioList.value.length
const lastId = audioList.value[len - 1]?.trackId
if (lastId === audios.trackId) {
uni.showToast({
title : "当前播放列表已是最新的了,请加载更多",
icon : "none"
})
return;
}
// 获取下一首的id
// 从播放列表寻找
let id = 0;
audioList.value.forEach((item, index) => {
if (item.trackId === audios.trackId) {
id = audioList.value[index + 1]?.trackId
}
})
getTrackInfo(id)
}

这里只需要注意的是,如果是第一个和最后一个音频,需要做特殊处理。


3.5 播放结束


最后,当某个音频播放结束的时候,直接请求nextAudio函数即可。


ctx.onEnded((e) => {
// 播放结束自动切换到下一首歌
nextAudio()
})

到此为止,我想要的功能基本全部实现了。


4. 更多功能



  • 实时上报播放进度

  • 音频地址防盗

  • 付费,免费体验功能


5. 代码地址


完整代码地址参考:gitee.com/xiumubai/li…


作者:白哥学前端
来源:juejin.cn/post/7226228585371041848
收起阅读 »

从解决一个页面请求太多的问题开始的

web
一、写在前面   上周测试同事给我提了个bug。他说在公司运营系统某个编辑页面中,一个post请求调用太多次了,想让我看看怎么回事。我刚听他讲这个事情时心里有点不屑一顾,觉得能有多少次啊,大惊小怪的。然而当我在测试环境中打开那个页面一看,直呼好家伙!这个页面...
继续阅读 »

一、写在前面




  上周测试同事给我提了个bug。他说在公司运营系统某个编辑页面中,一个post请求调用太多次了,想让我看看怎么回事。我刚听他讲这个事情时心里有点不屑一顾,觉得能有多少次啊,大惊小怪的。然而当我在测试环境中打开那个页面一看,直呼好家伙!这个页面调用了30次相同的请求,属实有点离谱的!


image-20230409202804026.png
  既然情况属实,那么肯定是需要优化一下的。我打开项目代码全局搜索这个请求,发现是在全局公用的一个 Upload 组件的created方法里面调用的。这个请求发送的目的是获取图片上传 oss 系统的签名。因为这个页面一共有30个 Upload 组件,所以整个页面渲染完成后会调用30次接口!!我接着查看接口请求返回的数据,发现签名的有效期是1小时。每次请求的发送又会重新刷新了这个签名和有效时间。但是为什么最先调用接口的 Upload 组件还能上传图片成功,这我还不知道。


  我灵机一动,如果把这个获取签名的方法单纯抽取出来。第一次调用方法后将返回数据缓存下来,后面请求时岂不美哉!但实际操作时发现事情没我想象的那么简单。。。


二、我的解决方案1.0




  一开始我的方案是使用 Vuex 缓存接口返回的签名数据,Upload 组件每次都先从 Vuex 中 state 中查找签名数据 cosConfig,如果没找到再去请求接口。大致的流程如下图:


image-20230410231612623.png


  在捋清楚后逻辑之后,我开始新写 Vuex 的 state 和对应的 mutation了。当我写完代码后一运行,发现这个也能还是依旧调用了30次请求。这让我我很是纳闷啊!!!无奈只好debugger语句开始一行行代码进行调试。
经过一小段时间的调试,问题被我发现了。那就是:签名数据的异步获取。这个签名数据是通过调用后端接口异步返回给前端的。当这个页面存在30个 Upload 组件时,每个组件都会在自己的 created 生命周期函数里先查找了 Vuex 中有没有缓存的签名数据。当页面第一次渲染时,vuex 中肯定是没有签名数据的。所以每个 Upload 组件都会找不到签名数据,然后每个组件都会继续调用接口获取签名数据。等获取到了签名之后,签名配置数据再缓存在 Vuex 中,也就没有意义了。所以方案一失败!!


三、我的解决方案2.0




  我需要承认的是平时困于重复性业务的开发中,很少去处理稍微复杂一点的问题,脑子容易混沌。我在发现方案1.0失败了之后,开始想其他的解决方案。通过 google 的无私帮助下,我找到了这篇文章([vue中多个相同组件重复请求的问题?]),完全就是和我一样的问题嘛。我进去看了第一个赞最多的回答,清晰透彻!主要的解决方案就是运用设计模式中的单例模式,把 Upload 组件中的获取签名的方案单独抽出来。这样子页面上不管有多少个 Upload 组件,调用的获取签名的方法都是同一个。这样子就可以在这个方法里面做文章了。


  那么要做什么文章呢?我们假设这个获取上传图片签名的方法名叫做 getCosConfig,无论多少个 Upload 组件,都是调用同一个 getCosConfig 方法。那么在这个方法外部添加一个缓存对象 cacheConfig,组件每次先从这个缓存对象查找存不存在配置数据。如果存在直接获取缓存对象,如果不存在就调用接口获取。


  但光是这样效果还是和方案1.0结果一样的,同样会调用30次接口。所以我们还需要加一个计数器变量 count。count 的初始值是0,Upload 组件每次发送请求时都会给 count 加1。这样子当我们发现是第一次请求时就去调用接口,不是第一次的话就等待,直到第一次请求结束获得数据。逻辑流程图如下:


image-20230415123202746.png


四、我的解决方案2.1




  到此,本以为这个问题完美解决,但是我突然发现这个接口有入参的!这个页面调用的30个接口中,其中两个剩余的28个参数是不同的。我赶忙去查询了接口文档,发现这个接口是用于获取图片上传的签名,并且不同的业务模块的存储位置是不同的。那么自然返回的上传签名也是不同的,这也意味着原来的 cosConfig 的数据结构是不对的。因为原来的一级对象结构会导致不同业务模块的签名数据混乱了,搞不好弄成了p0级的线上bug。想到这里我心里一凉,感慨还好我细心多瞅了一眼。


  既然问题已经定位到了,那么解决方案2.1自然而然也出来了,只要改造一下 co sConfig 和 count 的结构即可,增加一个key,变成二级的对象。最后我的代码成品如下:


image.png


image.png


五、总结




  最后总结一下,数据结构和设计原则的学习看似虚无缥缈,实际上能够帮助我们解决复杂度很高的问题。通过结合我们日常的开发工作,我们才能感受到这些知识的魅力,也会让我们更加有动力去提高我们的水平。


六、评论区其他方案推荐




 之前写文章都是自娱自乐,没啥人看。这篇文章不知道怎么看的人挺多,评论的朋友也不少。评论区也提出了不少其他方案和业界通用的解决方案,让我见识到了自己知识面的狭窄。我也总结一下供有需要的人使用:


1.【业务维度】在上传图片时再去获取服务端的token,不需要提前去获取。


2.【技术维度】一些请求库自带了去重的功能,例如vue-query。


3.【技术维度】缓存池的概念和处理,这个老哥写的很好【你不知道的promise】设计一个支持并发的前端接口缓存


4.【技术维度】使用异步单例模式,将请求的Promise缓存下来,再次调用函数的时候返回这个Promise。这篇文章讲的不错,给大家推荐一下高级异步模式 - Promise 单例


image.png


作者:徐徐徐叨叨
来源:juejin.cn/post/7222096611635003451
收起阅读 »

简述 js 的代码整洁之道

web
前言 为什么代码要整洁? 代码质量与整洁度成正比。有的团队在赶工期的时候,不注重代码的整洁,代码写的越来越糟糕,项目越来越混乱,生产力也跟着下降,那就必须找更多人来提高生产力,开发成本越来越高。 整洁的代码是怎样的? 清晰表达意图、消除重复、简单抽象、能通过测...
继续阅读 »

前言


为什么代码要整洁?


代码质量与整洁度成正比。有的团队在赶工期的时候,不注重代码的整洁,代码写的越来越糟糕,项目越来越混乱,生产力也跟着下降,那就必须找更多人来提高生产力,开发成本越来越高。


整洁的代码是怎样的?


清晰表达意图、消除重复、简单抽象、能通过测试。
换句话说:具有可读性、可重用性和可重构性。


命名




  1. 名副其实:不使用缩写、不使用让人误解的名称,不要让人推测。


    // bad: 啥?
    const yyyymmdstr = moment().format("YYYY/MM/DD");
    // bad: 缩写
    const cD = moment().format("YYYY/MM/DD");

    // good:
    const currentDate = moment().format("YYYY/MM/DD");

    const locations = ["Austin", "New York", "San Francisco"];

    // bad:推测l是locations的项
    locations.forEach(l => doSomeThing(l));

    // good
    locations.forEach(location => doSomeThing(location));



  2. 使用方便搜索的名称:避免硬编码,对数据用常量const记录。


    // bad: 86400000指的是?
    setTimeout(goToWork, 86400000);

    // good: 86400000是一天的毫秒数
    const MILLISECONDS_PER_DAY = 60 * 60 * 24 * 1000;
    setTimeout(goToWork, MILLISECONDS_PER_DAY);



  3. 类名应该是名词,方法名应该是动词。


    // bad
    function visble() {}

    // good
    function getVisble() {}



  4. 多个变量属于同一类型的属性,那就他们整合成一个对象。同时省略多余的上下文。


    // bad:可以整合
    const carMake = "Honda",
    const carModel = "Accord",
    const carColor = "Blue",

    // bad: 多余上下文
    const Car = {
    carMake: "Honda",
    carModel: "Accord",
    carColor: "Blue",
    };

    // good
    const Car = {
    make: "Honda",
    model: "Accord",
    color: "Blue",
    };



其他:




  • 不要写多余的废话,比如theMessagethe可以删除。




  • 统一术语。比如通知一词,不要一会在叫notice,一会叫announce




  • 用读得通顺的词语。比如getElementById就比 useIdToGetElement好读。




函数(方法)




  • 删除重复的代码,don't repeat yourself。很多地方可以注意dry,比如偷懒复制了某段代码、try...catch或条件语句写了重复的逻辑。


     // bad
    try {
    doSomeThing();
    clearStack();
    } catch (e) {
    handleError(e);
    clearStack();
    }
    // good
    try {
    doSomeThing();
    } catch (e) {
    handleError(e);
    } finally {
    clearStack();
    }



  • 形参不超过三个,对测试函数也方便。多了就使用对象参数。




    • 同时建议使用对象解构语法,有几个好处:



      1. 能清楚看到函数签名有哪些熟悉,

      2. 可以直接重新命名,

      3. 解构自带克隆,防止副作用,

      4. Linter检查到函数未使用的属性。




     // bad
    function createMenu(title, body, buttonText, cancellable) {}

    // good
    function createMenu({ title, body, buttonText, cancellable }) {}



  • 函数只做一件事,代码读起来更清晰,函数就能更好地组合、测试、重构。


     // bad: 处理了输入框的change事件,并创建文件的切片,并保存相关信息到localStorage
    function handleInputChange(e) {
    const file = e.target.files[0];
    // --- 切片 ---
    const chunkList = [];
    let cur = 0;
    while (cur < file.size) {
    chunkList.push({
    chunk: file.slice(cur, cur + size)
    });
    cur += size;
    }
    // --- 保存信息到localstorage ---
    localStorage.setItem("file", file.name);
    localStorage.setItem("chunkListLength", chunkList.length);
    }

    // good: 将三件事分开写,同时自顶而下读,很舒适
    function handleInputChange(e) {
    const file = e.target.files[0];
    const chunkList = createChunk(file);
    saveFileInfoInLocalStorage(file, chunkList);
    }
    function createChunk(file, size = SLICE_SIZE) {
    const chunkList = [];
    let cur = 0;
    while (cur < file.size) {
    chunkList.push({
    chunk: file.slice(cur, cur + size)
    });
    cur += size;
    }
    return chunkList
    }
    function saveFileInfoInLocalStorage(file, chunkList) {
    localStorage.setItem("file", file.name);
    localStorage.setItem("chunkListLength", chunkList.length);
    }



  • 自顶向下地书写函数,人们都是习惯自顶向下读代码,如,为了执行A,需要执行B,为了执行B,需要执行C。如果把A、B、C混在一个函数就很难读了。(看前一个的例子)。




  • 不使用布尔值来作为参数,遇到这种情况时,一定可以拆分函数。


     // bad
    function createFile(name, temp) {
    if (temp) {
    fs.create(`./temp/${name}`);
    } else {
    fs.create(name);
    }
    }

    // good
    function createFile(name) {
    fs.create(name);
    }

    function createTempFile(name) {
    createFile(`./temp/${name}`);
    }



  • 避免副作用。




    • 副作用的缺点:出现不可预期的异常,比如用户对购物车下单后,网络差而不断重试请求,这时如果添加新商品到购物车,就会导致新增的商品也会到下单的请求中。




    • 集中副作用:遇到不可避免的副作用时候,比如读写文件、上报日志,那就在一个地方集中处理副作用,不要在多个函数和类处理副作用。




    • 其它注意的地方:



      • 常见就是陷阱就是对象之间共享了状态,使用了可变的数据类型,比如对象和数组。对于可变的数据类型,使用immutable等库来高效克隆。

      • 避免用可变的全局变量。




    // bad:注意到cart是引用类型!
    const addItemToCart = (cart, item) => {
    cart.push({ item, date: Date.now() });
    };

    // good
    const addItemToCart = (cart, item) => {
    return [...cart, { item, date: Date.now() }];
    };



  • 封装复杂的判断条件,提高可读性。


     // bad
    if (!(obj => obj != null && typeof obj[Symbol.iterator] === 'function')) {
    throw new Error('params is not iterable')
    }

    // good
    const isIterable = obj => obj != null && typeof obj[Symbol.iterator] === 'function';
    if (!isIterable(promises)) {
    throw new Error('params is not iterable')
    }



  • 在方法中有多条件判断时候,为了提高函数的可扩展性,考虑下是不是可以使用能否使用多态性来解决。


     // 地图接口可能来自百度,也可能来自谷歌
    const googleMap = {
    show: function (size) {
    console.log('开始渲染谷歌地图', size));
    }
    };
    const baiduMap = {
    render: function (size) {
    console.log('开始渲染百度地图', size));
    }
    };

    // bad: 出现多个条件分支。如果要加一个腾讯地图,就又要改动renderMap函数。
    function renderMap(type) {
    const size = getSize();
    if (type === 'google') {
    googleMap.show(size);
    } else if (type === 'baidu') {
    baiduMap.render(size);
    }
    };
    renderMap('google')

    // good:实现多态处理。如果要加一个腾讯地图,不需要改动renderMap函数。
    // 细节:函数作为一等对象的语言中,作为参数传递也会返回不同的执行结果,也是“多态性”的体现。
    function renderMap (renderMapFromApi) {
    const size = getSize();
    renderMapFromApi(size);
    }
    renderMap((size) => googleMap.show(size));



其他




  • 如果用了TS,没必要做多余类型判断。




注释




  1. 一般代码要能清晰的表达意图,只有遇到复杂的逻辑时才注释。


     // good:由于函数名已经解释不清楚函数的用途了,所以注释里说明。
    // 在nums数组中找出 和为目标值 target 的两个整数,并返回它们的数组下标。
    const twoSum = function(nums, target) {
    let map = new Map()
    for (let i = 0; i < nums.length; i++) {
    const item = nums[i];
    const index = map.get(target - item)
    if (index !== undefined){
    return [index, i]
    }
    map.set(item, i)
    }
    return []
    };

    // bad:加了一堆废话
    const twoSum = function(nums, target) {
    // 声明map变量
    let map = new Map()
    // 遍历
    for (let i = 0; i < nums.length; i++) {
    const item = nums[i];
    const index = map.get(target - item)
    // 如果下标为空
    if (index !== undefined){
    return [index, i]
    }
    map.set(item, i)
    }
    return []
    };



  2. 警示作用,解释此处不能修改的原因。


    // hack: 由于XXX历史原因,只能调度一下。
    setTimeout(doSomething, 0)



  3. TODO注释,记录下应该做但还没做的工作。另一个好处,提前写好命名,可以帮助后来者统一命名风格。


    class Comment {
    // todo: 删除功能后期实现
    delete() {}
    }



  4. 没用的代码直接删除,不要注释,反正git提交历史记录可以找回。


    // bad: 如下,重写了一遍两数之和的实现方式

    // const twoSum = function(nums, target) {
    // for(let i = 0;i<nums.length;i++){
    // for(let j = i+1;j<nums.length;j++){
    // if (nums[i] + nums[j] === target) {
    // return [i,j]
    // }
    // }
    // }
    // };
    const twoSum = function(nums, target) {
    let map = new Map()
    for (let i = 0; i < nums.length; i++) {
    const item = nums[i];
    const index = map.get(target - item)
    if (index !== undefined){
    return [index, i]
    }
    map.set(item, i)
    }
    return []
    };



  5. 避免循规式注释,不要求每个函数都要求jsdoc,jsdoc一般是用在公共代码上。


    // bad or good?
    /**
    * @param {number[]} nums
    * @param {number} target
    * @return {number[]}
    */

    const twoSum = function(nums, target) {}



对象




  • 多使用getter和setter(getXXX和setXXX)。好处:



    • 在set时方便验证。

    • 可以添加埋点,和错误处理。

    • 可以延时加载对象的属性。


    // good
    function makeBankAccount() {
    let balance = 0;

    function getBalance() {
    return balance;
    }

    function setBalance(amount) {
    balance = amount;
    }

    return {
    getBalance,
    setBalance
    };
    }

    const account = makeBankAccount();
    account.setBalance(100);



  • 使用私有成员。对外隐藏不必要的内容。


    // bad
    const Employee = function(name) {
    this.name = name;
    };

    Employee.prototype.getName = function getName() {
    return this.name;
    };
    const employee = new Employee("John Doe");
    delete employee.name;
    console.log(employee.getName()); // undefined


    // good
    function makeEmployee(name) {
    return {
    getName() {
    return name;
    }
    };
    }




solid




  • 单一职责原则 (SRP) - 保证“每次改动只有一个修改理由”。因为如果一个类中有太多功能并且您修改了其中的一部分,则很难预期改动对其他功能的影响。


    // bad:设置操作和验证权限放在一起了
    class UserSettings {
    constructor(user) {
    this.user = user;
    }

    changeSettings(settings) {
    if (this.verifyCredentials()) {
    // ...
    }
    }

    verifyCredentials() {
    // ...
    }
    }
    // good: 拆出验证权限的类
    class UserAuth {
    constructor(user) {
    this.user = user;
    }

    verifyCredentials() {
    // ...
    }
    }

    class UserSettings {
    constructor(user) {
    this.user = user;
    this.auth = new UserAuth(user);
    }

    changeSettings(settings) {
    if (this.auth.verifyCredentials()) {
    // ...
    }
    }
    }



  • 开闭原则 (OCP) - 对扩展放开,但是对修改关闭。在不更改现有代码的情况下添加新功能。比如一个方法因为有switch的语句,每次出现新增条件时就要修改原来的方法。这时候不如换成多态的特性。


    // bad: 注意到fetch用条件语句了,不利于扩展
    class AjaxAdapter extends Adapter {
    constructor() {
    super();
    this.name = "ajaxAdapter";
    }
    }

    class NodeAdapter extends Adapter {
    constructor() {
    super();
    this.name = "nodeAdapter";
    }
    }

    class HttpRequester {
    constructor(adapter) {
    this.adapter = adapter;
    }

    fetch(url) {
    if (this.adapter.name === "ajaxAdapter") {
    return makeAjaxCall(url).then(response => {
    // transform response and return
    });
    } else if (this.adapter.name === "nodeAdapter") {
    return makeHttpCall(url).then(response => {
    // transform response and return
    });
    }
    }
    }

    function makeAjaxCall(url) {
    // request and return promise
    }

    function makeHttpCall(url) {
    // request and return promise
    }

    // good
    class AjaxAdapter extends Adapter {
    constructor() {
    super();
    this.name = "ajaxAdapter";
    }

    request(url) {
    // request and return promise
    }
    }

    class NodeAdapter extends Adapter {
    constructor() {
    super();
    this.name = "nodeAdapter";
    }

    request(url) {
    // request and return promise
    }
    }

    class HttpRequester {
    constructor(adapter) {
    this.adapter = adapter;
    }

    fetch(url) {
    return this.adapter.request(url).then(response => {
    // transform response and return
    });
    }
    }



  • 里氏替换原则 (LSP)




    • 两个定义



      • 如果S是T的子类,则T的对象可以替换为S的对象,而不会破坏程序。

      • 所有引用其父类对象方法的地方,都可以透明的替换为其子类对象。

      •     也就是,保证任何父类对象出现的地方,用其子类的对象来替换,不会出错。下面的例子是经典的正方形、长方形例子。




    // bad: 用正方形继承了长方形
    class Rectangle {
    constructor() {
    this.width = 0;
    this.height = 0;
    }

    setColor(color) {
    // ...
    }

    render(area) {
    // ...
    }

    setWidth(width) {
    this.width = width;
    }

    setHeight(height) {
    this.height = height;
    }

    getArea() {
    return this.width * this.height;
    }
    }

    class Square extends Rectangle {
    setWidth(width) {
    this.width = width;
    this.height = width;
    }

    setHeight(height) {
    this.width = height;
    this.height = height;
    }
    }

    function renderLargeRectangles(rectangles) {
    rectangles.forEach(rectangle => {
    rectangle.setWidth(4);
    rectangle.setHeight(5);
    const area = rectangle.getArea(); // BAD: 返回了25,其实应该是20
    rectangle.render(area);
    });
    }

    const rectangles = [new Rectangle(), new Rectangle(), new Square()];// 这里替换了
    renderLargeRectangles(rectangles);

    // good: 取消正方形和长方形继承关系,都继承Shape
    class Shape {
    setColor(color) {
    // ...
    }

    render(area) {
    // ...
    }
    }

    class Rectangle extends Shape {
    constructor(width, height) {
    super();
    this.width = width;
    this.height = height;
    }

    getArea() {
    return this.width * this.height;
    }
    }

    class Square extends Shape {
    constructor(length) {
    super();
    this.length = length;
    }

    getArea() {
    return this.length * this.length;
    }
    }

    function renderLargeShapes(shapes) {
    shapes.forEach(shape => {
    const area = shape.getArea();
    shape.render(area);
    });
    }

    const shapes = [new Rectangle(4, 5), new Rectangle(4, 5), new Square(5)];
    renderLargeShapes(shapes);



  • 接口隔离原则 (ISP) - 定义是"客户不应被迫使用对其而言无用的方法或功能"。常见的就是让一些参数变成可选的。


     // bad
    class Dog {
    constructor(options) {
    this.options = options;
    }

    run() {
    this.options.run(); // 必须传入 run 方法,不然报错
    }
    }

    const dog = new Dog({}); // Uncaught TypeError: this.options.run is not a function

    dog.run()

    // good
    class Dog {
    constructor(options) {
    this.options = options;
    }

    run() {
    if (this.options.run) {
    this.options.run();
    return;
    }
    console.log('跑步');
    }
    }



  • 依赖倒置原则(DIP) - 程序要依赖于抽象接口(可以理解为入参),不要依赖于具体实现。这样可以减少耦合度。


     // bad
    class OldReporter {
    report(info) {
    // ...
    }
    }

    class Message {
    constructor(options) {
    // ...
    // BAD: 这里依赖了一个实例,那你以后要换一个,就麻烦了
    this.reporter = new OldReporter();
    }

    share() {
    this.reporter.report('start share');
    // ...
    }
    }

    // good
    class Message {
    constructor(options) {
    // reporter 作为选项,可以随意换了
    this.reporter = this.options.reporter;
    }

    share() {
    this.reporter.report('start share');
    // ...
    }
    }
    class NewReporter {
    report(info) {
    // ...
    }
    }
    new Message({ reporter: new NewReporter });



其他




  • 优先使用 ES2015/ES6 类而不是 ES5 普通函数。




  • 多使用方法链。




  • 多使用组合而不是继承。




错误处理




  • 不要忽略捕获的错误。而要充分对错误做出反应,比如console.error()到控制台,提交错误日志,提醒用户等操作。




  • 不要漏了catch promise中的reject。




格式


可以使用eslint工具,这里就不展开说了。


最后


接受第一次愚弄


让程序一开始就做到整洁,并不是一件很容易的事情。不要强迫症一样地反复更改代码,因为工期有限,没那么多时间。等到下次需求更迭,你发现到代码存在的问题时,再改也不迟。


入乡随俗


每个公司、项目的代码风格是不一样的,会有与本文建议不同的地方。如果你接手了一个成熟的项目,建议按照此项目的风格继续写代码(不重构的话)。因为形成统一的代码风格也是一种代码整洁。



参考:



  1. 《代码整洁之道》

  2. github.com/ryanmcdermo…
    (里面有很多例子。有汉化但没更新)


作者:xuwentao
来源:juejin.cn/post/7224382896626778172

收起阅读 »

ES6 Class类,就是构造函数语法糖?

web
一、Class 类可以看作是构造函数的语法糖 ES6引入了 Class(类)这个概念,作为对象的模板。通过class关键字,可以定义类。constructor()方法,这就是构造方法,而this关键字则代表实例对象。类的所有方法都定义在类的prototype...
继续阅读 »

一、Class 类可以看作是构造函数的语法糖



ES6引入了 Class(类)这个概念,作为对象的模板。通过class关键字,可以定义类。constructor()方法,这就是构造方法,而this关键字则代表实例对象。类的所有方法都定义在类的prototype属性上面,方法前面不需要加上function这个关键字,直接把函数定义放进去了就可以了。使用的时候,类必须使用new调用跟构造函数的用法完全一致。



  • 类不存在变量提升



    class Point {
constructor(x, y) {
this.x = x;
this.y = y;
}

toString() {
return '(' + this.x + ', ' + this.y + ')';
}
}
var p = new Point(1, 2);

通过代码证明:


    class Point {
// ...
}

typeof Point // "function"
Point === Point.prototype.constructor // true

类的数据类型就是函数,类本身就指向构造函数。



constructor: 方法是类的默认方法,通过new命令生成对象实例时,自动调用该方法。一个类必须有constructor()方法,如果没有显式定义,一个空的constructor()方法会被默认添加。



class Point {
}

// 等同于
class Point {
constructor() {}
}

取值函数(getter)和存值函数(setter)


        class Person {
constructor(name, age) {
this.name = name
this.age = age
}

get nl() {
return this.age
}

set nl(value) {
this.age = value
}
}
let p = new Person('fzw', 25)
console.log(p.nl);
p.nl = 44
console.log(p.nl);

class表达式


        let person = new class {
constructor(name) {
this.name = name;
}

sayName() {
console.log(this.name);
}
}('张三');

person.sayName(); // "张三"


上面代码中,person是一个立即执行的类的实例。


二、静态方法、静态属性



类相当于实例的原型,所有在类中定义的方法,都会被实例继承。如果在一个方法前,加上static关键字,就表示该方法不会被实例继承,而是直接通过类来调用,这就称为“静态方法”。



         class Foo {
static classMethod() {
this.baz(); // 'hello'
return '我被调用了';
}
static baz() {
console.log('hello');
}
baz() {
console.log('world');
}
}

console.log(Foo.classMethod()); // 我被调用了

var foo = new Foo();
foo.classMethod() // TypeError: foo.classMethod is not a function

注意 如果静态方法包含this关键字,这个this指的是类,而不是实例。静态方法可以与非静态方法重名。


        class Foo {
static classMethod() {
return 'hello';
}
}

class Bar extends Foo {
}

Bar.classMethod() // 'hello'

父类的静态方法,可以被子类继承。父类Foo有一个静态方法,子类Bar可以调用这个方法。
静态方法也是可以从super对象上调用的。


        class Foo {
static classMethod() {
return 'hello';
}
}

class Bar extends Foo {
static classMethod() {
// super在静态方法之中指向父类
return super.classMethod() + ', too';
}
}

console.log(Bar.classMethod());

注意 super 在静态方法之中指向父类。


静态属性



static 关键词修饰,可继承使用



         class MyClass {
static myStaticProp = 42;
constructor() {
console.log(MyClass.myStaticProp); // 42
}
}
class Bar extends MyClass {
}
new MyClass()
console.log(Bar.myStaticProp);

三、私有方法和私有属性



#修饰属性或方法,私有属性和方法只能在类的内部使用。
私有属性也可以设置 getter 和 setter 方法
私有属性和私有方法前面,也可以加上static关键字,表示这是一个静态的私有属性或私有方法。



    class Counter {
#xValue = 0;

constructor() {
console.log(this.#x);
}

get #x() { return this.#xValue; }
set #x(value) {
this.#xValue = value;
}
}

四、class 继承




  • Class 可以通过extends关键字实现继承,让子类继承父类的属性和方法。

  • ES6 规定,子类必须在constructor()方法中调用super(),如果不调用super()方法,子类就得不到自己的this对象。调用super()方法会执行一次父类构造函数。

  • 在子类的构造函数中,只有调用super()之后,才可以使用this关键字,



        class Foo {
constructor() {
console.log(1);
}
}

class Bar extends Foo {
constructor(color) {
// this.color = color; // ReferenceError
super();
this.color = color; // 正确
}
}

const bar = new Bar('blue');
console.log(bar); // Bar {color: 'blue'}

super 关键字



super这个关键字,既可以当作函数使用,也可以当作对象使用。



  • super作为函数调用时,代表父类的构造函数。只能用在子类的构造函数之中,用在其他地方就会报错。

  • super作为对象时,在普通方法中,指向父类的原型对象;在静态方法中,指向父类。



作为对象,普通方法中super指向父类的原型对象


    class A {
constructor() {
this.x = 1;
}
print() {
console.log(this.x);
}
}

class B extends A {
constructor() {
super();
this.x = 2;
}
m() {
super.print();
}
}

let b = new B();
b.m() // 2

注意:
在子类普通方法中通过super调用父类的方法时,方法内部的this指向当前的子类实例。


作为对象,静态方法之中,这时super将指向父类


        class Parent {
static myMethod(msg) {
console.log('static', msg);
}

myMethod(msg) {
console.log('instance', msg);
}
}

class Child extends Parent {
static myMethod(msg) {
// super 代表父类
super.myMethod(msg);
}

myMethod(msg) {
// super 代表父类原型对象
super.myMethod(msg);
}
}

Child.myMethod(1); // static 1

var child = new Child();
child.myMethod(2); // instance 2

extends 关键字


168fb9a3828f9cb4_tplv-t2oaga2asx-zoom-in-crop-mark_4536_0_0_0.awebp
    // 1、构造器原型链
Child.__proto__ === Parent; // true
Parent.__proto__ === Function.prototype; // true
Function.prototype.__proto__ === Object.prototype; // true
Object.prototype.__proto__ === null; // true
// 2、实例原型链
child.__proto__ === Child.prototype; // true
Child.prototype.__proto__ === Parent.prototype; // true
Parent.prototype.__proto__ === Object.prototype; // true
Object.prototype.__proto__ === null; // true


extends 继承,主要就是:



  1. 把子类构造函数(Child)的原型(__proto__)指向了父类构造函数(Parent),

  2. 把子类实例child的原型对象(Child.prototype) 的原型(__proto__)指向了父类parent的原型对象(Parent.prototype)。


这两点也就是图中用不同颜色标记的两条线。



子类构造函数Child继承了父类构造函数Parent的里的属性,使用super调用的。




作者:f_人生如戏
来源:juejin.cn/post/7225511164125855781
收起阅读 »

深拷贝的终极实现

web
引子 通过本文可以学习到深拷贝的三种写法的实现思路与性能差异 首先,我们要理解什么是深拷贝,以及为什么要实现深拷贝 深拷贝是什么 通俗来讲,深拷贝就是深层的拷贝一个变量值; 为什么要实现深拷贝 因为在拷贝引用值时,由于复制一个变量只是将其指向要复制变量的引...
继续阅读 »

引子



通过本文可以学习到深拷贝的三种写法的实现思路与性能差异



首先,我们要理解什么是深拷贝,以及为什么要实现深拷贝


深拷贝是什么


通俗来讲,深拷贝就是深层的拷贝一个变量值;


为什么要实现深拷贝


因为在拷贝引用值时,由于复制一个变量只是将其指向要复制变量的引用内存地址,他们并没有完全的断开,而使用就可以实现深拷贝将其完全拷贝为两个单独的存在,指向不同的内存地址;


如何实现深拷贝


一行实现


let deepClone = JSON.parse(JSON.stringify(obj))

这种是最简单的实现方法,虽然这个方法适用于常规,但缺点是无法拷贝 Date()或是RegExp()
 


简单实现


function deepClone(obj) {
// 判断是否是对象
if (typeof obj !== 'object') return obj
// 判断是否是数组 如果是数组就返回一个新数组 否则返回一个新对象
var newObj = obj instanceof Array ? [] : {};
// 遍历obj
for (var key in obj) {
// 将key值拷贝,再层层递进拷贝对象的值
newObj[key] = deepClone(obj[key]);
}
// 返回最终拷贝完的值
return newObj;
}

对于普通的值(如数值、字符串、布尔值)和常见的引用类型(如对象和数组),这个写法完全够用。


但是这个写法有个缺陷,就是无法正确拷贝 Date()  和  RegExp()  等实例对象,因为少了对这些引用类型的特殊处理


普通版


function deepClone(origin, target) {
let tar = target || {};
for (var key in origin) {
if (origin.hasOwnProperty(key)) {
if (typeof origin[key] === 'object' && origin[key] !== null) {
tar[key] = Array.isArray(origin[key]) ? [] : {};
deepClone(origin[key], tar[key]);
} else {
tar[key] = origin[key];
}
}
}
return tar;
}

这个深拷贝方法通过判断属性的值类型,实现了对 对象数组 以及 DateRegExp 等引用类型对象的递归拷贝,同时也考虑了拷贝基本类型值的情况,能够满足大多数场景的要求。


最终版


为什么还有最终版?

上面的案例,可以应对一般场景。


但是对于有两个对象相互拷贝的场景,会导致循环的无限递归,造成死循环!



Uncaught RangeError: Maximum call stack size exceeded



场景:


image.png


如何解决无限递归的问题?

首先我们要了解 WeakMap()
WeakMap的键名所指向的对象,不计入垃圾回收机制;


而通过 WeakMap 记录已经拷贝过的对象,能防止循环引用导致的无限递归;



WeakMap 的设计目的在于,有时我们想在某个对象上面存放一些数据,但是这会形成对于这个对象的引用



代码

利用 WeakMap() 在属性遍历完绑定,并在每次循环时获取当前键名,如果存在则返回数据,不存在则拷贝


function deepClone(origin, hashMap = new WeakMap()) {
// 判断是否是对象
if (origin == undefined || typeof origin !== 'object') return origin;
// 判断是否是Date类型
if (origin instanceof Date) return new Date(origin);
if (origin instanceof RegExp) return new RegExp(origin);

// 判断是否是数组
const hashKey = hashMap.get(origin);
// 如果是数组
if (hashKey) return hashKey;

// 从原型上复制一个值
// *:利用原型构造器获取新的对象 如: [], {}
const target = new origin.constructor();
// 将对象存入map
hashMap.set(origin, target);
// 循环遍历当前层数据
for (let k in origin) {
// 判断当前属性是否为引用类型
if (origin.hasOwnProperty(k)) {
target[k] = deepClone(origin[k], hashMap);
}
}
return target;
}

我们再来看一下使用最新版后的两个对象互相拷贝:


image.png


可以看到,通过使用 WeakMap 记录已经拷贝的对象,有效防止循环引用导致的栈溢出错误,是功能最完备的深拷贝实现。


总结


深拷贝可以完全拷贝一个对象,生成两个独立的且相互不影响的对象。


明白各种深拷贝实现的思路和性能差异,可以在不同场景选用最优的方案。


作者:Shrimpsss
来源:juejin.cn/post/7226181917997547576
收起阅读 »

关于前端实现上传文件这个功能,我只能说so easy!

web
前言 在web前端开发中,文件上传属于很常见的功能,不论是图片、还是文档等等资源,或多或少会有上传的需求。一般都是从添加文件开始,然后读取文件信息,再通过一定的方式将文件上传到服务器上,以供后续展示或下载使用。 下面简单介绍几种上传的方法 简单文件上传 文件上...
继续阅读 »

前言


在web前端开发中,文件上传属于很常见的功能,不论是图片、还是文档等等资源,或多或少会有上传的需求。一般都是从添加文件开始,然后读取文件信息,再通过一定的方式将文件上传到服务器上,以供后续展示或下载使用。


下面简单介绍几种上传的方法


简单文件上传


文件上传的传统形式,是使用表单元素 file


<input type="file" id="file-uploader">

你可以添加 change 事件监听器读取 event.target.files 文件对象。


const fileUploader = document.getElementById('file-uploader')
fileUploader.addEventListener('change', (e) => {
const files = e.target.files
console.log('files', files)
})

多个文件上传


使用 multiple 属性


<input type="file" id="file-uploader" multiple />

文件元数据


在成功上传文件内容后,您可能需要显示该文件内容。对于图片,如果我们在上传后不立即将上传的图片显示给用户,则会感到困惑。


每当上传文件时,File 对象都会包含元数据信息,如文件名称、大小、上次更新时间、类型等。此信息可用于进一步验证和决策。


const fileUploader = document.getElementById('file-uploader')

// 侦听更改事件并读取元数据
fileUploader.addEventListener('change', (e) => {
// 获取文件列表数组
const files = e.target.files

// 循环浏览文件并获取元数据
for (const file of files) {
const name = file.name
const type = file.type ? file.type: 'NA'
const size = file.size
const lastModified = file.lastModified
console.log({ file, name, type, size, lastModified })
}
})

上传前预览图像


我们准备一个上传文件控件,并为预览所选文件准备 img 元素,结构如下:


<input type="file" id="fileInput" />

<img id="preview" />

getElementById() 方法可以获取这两个元素:


const fileEle = document.getElementById('fileInput')
const previewEle = document.getElementById('preview')

使用 URL.createObjectURL() 方法


URL.createObjectURL() 方法包含一个表示参数中给出的对象的 URL。这个新的 URL 对象表示指定的 File对象或 Blob 对象。


fileEle.addEventListener('change', function (e) {
// 获取所选文件
const file = e.target.files[0]

// 创建引用该文件的新 URL
const url = URL.createObjectURL(file)

// 设置预览元素的源
previewEle.src = url
})

使用 FileReader 的 readAsDataURL() 方法



  • 使用 FileReader 对象将文件转换为二进制字符串。然后添加 load 事件侦听器,以获得成功文件上传的二进制字符串。

  • FileReader.readAsDataURL() 方法用于读取指定的 BlobFile对象。


// 获取 FileReader 的实例
const reader = new FileReader()

fileUploader.addEventListener('change', (e) => {
const files = e.target.files
const file = files[0]

// 上传后获取文件对象,以 URL 二进制字符串的形式读取数据
reader.readAsDataURL(file)

// 加载后,对字符串进行处理
reader.addEventListener('load', (e) => {
// 设置预览元素的源
previewEle.src = reader.result
})
})

accept 属性


使用 accept 属性来限制要上传的文件类型。


<input type="file" id="file-uploader" accept=".jpg, .png" multiple>

上面示例中,浏览器将只允许具有 .jpg 和 .png 的文件类型。


验证文件大小


我们读取了文件的大小元数据,可以使用它进行文件大小验证。您可以允许用户上传高达 1MB 的图像文件。


// 文件上载更改事件的侦听器
fileUploader.addEventListener('change', (event) => {
// 读取文件大小
const file = event.target.files[0]
const size = file.size

let msg = ''

// 检查文件大小是否大于 1MB,提示对应消息。
if (size > 1024 * 1024) {
msg = `<span style="color: red;">允许的文件大小为 1MB。您尝试上载的文件属于${returnFileSize(size)}</span>`
} else {
msg = `<span style="color: green;"> ${returnFileSize(size)} 文件已成功上载。 </span>`
}

// 向用户显示消息
feedback.innerHTML = msg
})

显示文件上传进度


更好的可用性是让用户了解文件上传进度。XMLHttpRequest 第二版还定义了一个 progress 事件,可以用来制作进度条。


先在页面中放置一个 progress 标签


<label id="progress-label" for="progress"></label>
<progress id="progress" value="0" max="100" value="0">0</progress>

定义 progress 事件的回调函数


const reader = new FileReader()

reader.addEventListener('progress', (e) => {
if (e.loaded && e.total) {
// 计算完成百分比
const percent = (e.loaded / e.total) * 100
// 将值设置为进度组件
progress.value = percent
}
})

上传目录



有一个非标准属性 webkitdirectory,使我们能够上传整个目录。
虽然最初仅针对基于 WebKit 的浏览器实施,但 WebkitDirectory 在微软 Edge 以及 Firefox 50 及以后也可用。然而,即使它有相对广泛的支持,它仍然不是标准的,不应该使用,除非你别无选择。



<input type="file" id="file-uploader" webkitdirectory />

拖放上传


主要的 JS 如下:


const dropZone = document.getElementById('drop-zone')
const content = document.getElementById('content')

dropZone.addEventListener('dragover', event => {
event.stopPropagation()
event.preventDefault()
event.dataTransfer.dropEffect = 'copy'
})
dropZone.addEventListener('drop', event => {
// 获取文件
const files = event.dataTransfer.files
// ..
})

用对象处理文件


使用 URL.createObjectURL() 方法从文件创建一个唯一的 URL。使用 URL.revokeObjectURL() 方法释放它。



DOM 和 URL.createObjectURL()URL.revokeObjectURL() 方法允许您创建简单的 URL 字符串,可用于引用任何可以使用 DOM 文件对象引用的数据,包括用户计算机上的本地文件。



示例:


<div>
<h1>使用 Object URL</h1>
<input type="file" id="file-uploader" accept=".jpg, .jpeg, .png" >
<div id="image-grid"></div>
</div>

const fileUploader = document.getElementById('file-uploader')
const reader = new FileReader()
const imageGrid = document.getElementById('image-grid')

fileUploader.addEventListener('change', (event) => {
const files = event.target.files
const file = files[0]

const img = document.createElement('img')
imageGrid.appendChild(img)
img.src = URL.createObjectURL(file)
img.alt = file.name
})

总结



  1. 表单元素 file

  2. 文件元数据

  3. 上传前预览图像

  4. URL.createObjectURL() 方法

  5. 使用 FileReader 的 readAsDataURL() 方法

  6. accept
    作者:整天想死的鱼
    来源:juejin.cn/post/7224402365452238906
    属性

收起阅读 »

十个高阶Javascript知识及用法

web
hi,今天给大家整理了十个Javascript的高级知识,希望对你有所帮助 1. 高阶函数 高阶函数是指接受一个或多个函数作为参数,并/或者返回一个函数的函数。这种技巧可以用于将函数组合起来,实现函数的复用。 // 高阶函数示例:将一个数组中的所有元素相加 ...
继续阅读 »

hi,今天给大家整理了十个Javascript的高级知识,希望对你有所帮助




1. 高阶函数


高阶函数是指接受一个或多个函数作为参数,并/或者返回一个函数的函数。这种技巧可以用于将函数组合起来,实现函数的复用。


// 高阶函数示例:将一个数组中的所有元素相加
function add(...args) {
return args.reduce((a, b) => a + b, 0);
}
function addArrayElements(arr, fn) {
return fn(...arr);
}
const arr = [1, 2, 3, 4, 5];
const sum = addArrayElements(arr, add);
console.log(sum); // 15

2. 纯函数


纯函数是指没有副作用(不改变外部状态)并且输出仅由输入决定的函数。纯函数可以更容易地进行单元测试和调试,并且可以更好地支持函数式编程的概念。


// 纯函数示例:将一个数组中的所有元素转换为字符串
function arrToString(arr) {
return arr.map(String);
}
const arr = [1, 2, 3, 4, 5];
const strArr = arrToString(arr);
console.log(strArr); // ["1", "2", "3", "4", "5"]

3. 闭包


闭包是指一个函数可以访问其定义范围之外的变量。这种技巧可以用于将变量“私有化”,从而避免全局变量的滥用。


// 闭包示例:使用闭包实现计数器
function makeCounter() {
let count = 0;
return function() {
count++;
console.log(count);
};
}
const counter = makeCounter();
counter(); // 1
counter(); // 2
counter(); // 3

4. 柯里化


柯里化是指将一个接受多个参数的函数转换为一个接受一个参数的函数序列的技巧。这种技巧可以用于将函数变得更加通用化。


// 柯里化示例:将一个接受多个参数的函数转换为一个接受一个参数的函数序列
function add(a) {
return function(b) {
return a + b;
};
}
const add5 = add(5);
console.log(add5(10)); // 15
console.log(add5(20)); // 25

5. 函数组合


函数组合是指将多个函数组合成一个函数的技巧。这种技巧可以用于将多个函数的输出传递给下一个函数,实现函数的复用。


// 函数组合示例:将多个函数组合成一个函数
function add(a, b) {
return a + b;
}
function multiply(a, b) {
return a * b;
}
function compose(...fns) {
return function(x, y) {
return fns.reduce((acc, fn) => fn(acc, y), x);
};
}
const addAndMultiply = compose(add, multiply);
console.log(addAndMultiply(2, 3)); // 15

6. 函数记忆化


函数记忆化是指使用缓存来保存函数的结果,从而避免重复计算。这种技巧可以用于提高函数的性能。


// 函数记忆化示例:使用缓存来保存函数的结果
function memoize(fn) {
const cache = {};
return function(...args) {
const key = JSON.stringify(args);
if (cache[key]) {
return cache[key];
}
const result = fn(...args);
cache[key] = result;
return result;
};
}
function add(a, b) {
console.log("Calculating sum...");
return a + b;
}
const memoizedAdd = memoize(add);
console.log(memoizedAdd(2, 3)); // Calculating sum... 5
console.log(memoizedAdd(2, 3)); // 5 (from cache)

7. 类和继承


类和继承是指使用面向对象编程的概念来组织代码的技巧。这种技巧可以用于使代码更加模块化和可维护。


// 类和继承示例:使用类和继承实现动物类和猫类
class Animal {
constructor(name, age) {
this.name = name;
this.age = age;
}
speak() {
console.log("I am an animal.");
}
}
class Cat extends Animal {
constructor(name, age, color) {
super(name, age);
this.color = color;
}
speak() {
console.log("Meow!");
}
}
const cat = new Cat("Fluffy", 2, "black");

8. Generator


Generator 是一种特殊的函数,它可以暂停和恢复执行,并且可以用来生成迭代器。
示例代码:


function* generate() {
yield 1;
yield 2;
yield 3;
}
const iterator = generate();
console.log(iterator.next()); // 输出 { value: 1, done: false }
console.log(iterator.next()); // 输出 { value: 2, done: false }
console.log(iterator.next()); // 输出 { value: 3, done: false }
console.log(iterator.next()); // 输出 { value: undefined, done: true }

9. Proxy


Proxy 是一种对象代理机制,它可以拦截对象的访问、赋值、删除等操作,并且可以用来实现数据校验、数据缓存等功能。
示例代码:


const user = {
name: 'John',
age: 30,
};
const proxy = new Proxy(user, {
get(target, key) {
console.log(`Getting ${key} value.`);
return target[key];
},
set(target, key, value) {
console.log(`Setting ${key} value to ${value}.`);
target[key] = value;
},
});
console.log(proxy.name); // 输出 "Getting name value." 和 "John"
proxy.age = 40; // 输出 "Setting age value to 40."

10. Reflect


Reflect 是一种对象反射机制,它提供了一系列操作对象的方法,并且可以用来替代一些原来只能通过 Object 上的方法来实现的功能。
示例代码:


const user = {
name: 'John',
age: 30,
};
console.log(Reflect.has(user, 'name')); // 输出 true
console.log(Reflect.get(user, 'name')); // 输出 "John"
console.log(Reflect.set(user, 'age', 40)); // 输出 true
console.log(user.age); // 输出 40

image.png


作者:一条小尾鱼
来源:juejin.cn/post/7222838155605639226
收起阅读 »

打造高性能CSS的九个技巧

web
大佬:你的CSS的写的质量太低,看的我难受。 萌新:那要怎么样? 大佬:自己去优化一下。 萌新:额。。。CSS还能怎么样优化? 咳咳。。。咱们进入正题。 当前端项目想做到极致的性能与体验,优化CSS代码是非常重要的一环。优化CSS代码能够减少页面加载时间,提...
继续阅读 »

大佬:你的CSS的写的质量太低,看的我难受。


萌新:那要怎么样?


大佬:自己去优化一下。


萌新:额。。。CSS还能怎么样优化?


218585ea773deab374b233c6f64dda23.jpeg


咳咳。。。咱们进入正题。


当前端项目想做到极致的性能与体验,优化CSS代码是非常重要的一环。优化CSS代码能够减少页面加载时间,提升性能,改善用户体验。前端的同学有没有想过如何在项目中把CSS这一环优化?


下面我将给大家介绍优化CSS的9个技巧。


1. 使用简洁的选择器


选择器越短,浏览器匹配就越快。因此在编写CSS时,应该尽可能使用简洁的选择器。例如,优先使用类选择器和标签选择器,而不是id选择器和属性选择器。应该避免使用通配符选择器。


/* 优化前的代码 */
#sidebar ul li a:hover {
color: red;
}
/* 优化后的代码 */
.sidebar a:hover {
color: red;
}

2. 避免嵌套过深


嵌套过深会增加选择器的复杂度,影响浏览器性能,同时也使得代码难以维护。为了避免嵌套过深,可以采用命名约定,或者使用后代选择器代替嵌套。


/* 优化前的代码 */
#header .nav ul li a {
color: red;
}
/* 优化后的代码 */
.header-nav-link {
color: red;
}

3. 减少重复的样式


重复的样式会让CSS文件变得臃肿,增加文件大小,影响页面加载速度。如果某些样式被多处引用,可以将其定义为一个class或者使用CSS变量。


/* 优化前的代码 */
#sidebar h3 {
font-size: 1.5rem;
color: #333;
margin-bottom: 1rem;
}
#main h3 {
font-size: 1.5rem;
color: #333;
margin-bottom: 1rem;
}
/* 优化后的代码 */
.heading {
font-size: 1.5rem;
color: #333;
margin-bottom: 1rem;
}

4. 避免使用昂贵的属性


有些CSS属性会影响浏览器性能,例如position、float、display等。应该尽可能避免使用这些属性,或者使用更轻量级的替代方案。


/* 优化前的代码 */
#header {
position: absolute;
top: 0;
left: 0;
}
/* 优化后的代码 */
.header {
position: sticky;
top: 0;
z-index: 999;
}

5. 压缩CSS文件


压缩CSS文件是一种简单而有效的优化方式。压缩CSS文件可以删除注释和空格等无用代码,减少文件大小,加快页面加载速度。可以使用在线压缩工具或者构建工具自动压缩CSS文件。


例如:


/* 压缩前的代码 */
.header {
position: sticky;
top: 0;
z-index: 999;
}
/* 压缩后的代码 */
.header{position:sticky;top:0;z-index:999;}

6. 单独使用!important


!important能够优先级最高控制CSS属性值,但这种方法很容易过分使用,在大的CSS文件中成为代码的混乱来源。尝试尽可能避免使用它们,只在必要的情况下使用。


7. 避免使用通配符选择器


通配符选择器(*)会匹配所有元素,这样的选择器不仅速度慢,而且可能会导致CSS规则被某些你不想匹配的元素使用。因此,尽量避免使用通配符选择器。如果必须使用,也应该在选择器中增加额外的限制条件来提高精确度。


8.使用CSS继承


CSS继承能够将子元素的样式设置为与其父元素相同的属性值。这种方法不仅简单,而且可以减少代码量和增强代码的可读性。使用继承可以减少你的样式表中的重复代码。


9. 使用CSS预处理器


CSS预处理器(如Sass、Less、Stylus)能够让你使用变量、嵌套、函数、注释等高级功能,从而更加简洁、易于维护的方式编写CSS代码。预处理器将会自动将这些代码转换为标准CSS语法,这样能够降低代码量和复杂度,提高开发效率。


作者:白椰子
来源:juejin.cn/post/7223598443666964517
收起阅读 »

⏰⏰ 手把手实现一个进度条时钟,麻麻再也不用担心我把时间看茬了!

web
前言 挂钟大家都知道吧,它通过时针、分针和秒针来表示时间,想当初小学刚开始教怎么看时钟的完全看不懂。今天带大家一步步实现一个类进度条时钟的效果,更直观的知晓当前的时间。 本文将会带大家学到以下知识点: 垂直水平居中方式 gap 属性搭配 flex 布局 实现...
继续阅读 »

前言


挂钟大家都知道吧,它通过时针、分针和秒针来表示时间,想当初小学刚开始教怎么看时钟的完全看不懂。今天带大家一步步实现一个类进度条时钟的效果,更直观的知晓当前的时间。


本文将会带大家学到以下知识点:



  1. 垂直水平居中方式

  2. gap 属性搭配 flex 布局 实现等边距

  3. Date 日期函数的使用及注意点

  4. CSS 变量的简单应用

  5. svgcircle 标签的用法

  6. stroke-dashoffset 属性和 stroke-dasharray 属性能够的用法


样式重置


首先老规矩,我们将 CSS 样式重置 ,方便各个浏览器统一展示效果。


* {
margin: 0;
padding: 0;
box-sizing: border-box;
}

背景调整


接下来通过添加 min-height: 100vh 属性,将 body 限制为 视口大小 且通过 overflow: hidden 来将 超出部分隐藏


body {
display: flex;
justify-content: center;
align-items: center;
min-height: 100vh;
background-color: #2f363e;
}

这里为了将我们的时钟在屏幕中间展示,我们需要使用 flex 布局body 设置为 水平垂直居中 。同样的,小伙伴们还可以使用 light-heighttransform 等手段实现。


时间绘制


接下来我们要准备 4 个 div ,用来作为展示时间的容器。


<body>
<div id="time">
<div class="circle">
<div id="hours">00</div>
</div>
<div class="circle">
<div id="minutes">00</div>
</div>
<div class="circle">
<div id="seconds">00</div>
</div>
<div class="ap">
<div id="ampm">00</div>
</div>
</div>

</body>

然后给其宽高。


#time {
display: flex;
color: #fff;
}
#time .circle {
position: relative;
width: 150px;
height: 150px;
}

细心的小伙伴一定注意到了这段 CSS 中有个比较特别的属性:gap。这有什么用呢?


我们来看看 MDN 对 gap 属性的描述:



CSS gap 属性是用来设置网格行与列之间的间隙(gutters),该属性是 row-gap 和 column-gap 的简写形式。



gap 属性它适用于 multi-column elements, flex containers, grid containers,也就是多列布局、弹性布局以及网格布局中(知识点++)。因此这里我们用 flex 布局 搭配 gap 是完全行得通的。


我们看看此时的效果如何:


微信截图_20221011180851.png


我们发现最后一个用来表示上午下午的字体有点大,我们将其调小,同时通过 translateY 属性将该元素偏移 -20px(负数表示向上偏移,正数表示向下偏移),和时间做区分。


#time .ap {
position: relative;
font-size: 1em;
transform: translateY(-20px);
}

微信截图_20221011182321.png


这样美观了许多,主次分明。


动态时间


接下来我们要让时间变成实时的,因此我们要用到 Javascript 的 Date 函数了。



  1. 通过 getHours() 获取当前小时数。

  2. 通过 getMinutes() 获取当前分钟数。

  3. 通过 getSeconds() 获取当前秒钟数。


这里有个注意点,通过以上三个方法获取的时间值,都是不带前缀 0 的,并且是 number 类型。什么意思呢?


比如现在是下午的 14:07:04 ,通过 getMinutes() 获取的分钟数是 7 而不是 07,同理,通过 getSeconds()getHours() 获取的时间也是如此。


因此为了美观,我们需要手动给 10 以内 的时间值 补一个 0。具体怎么做呢?这里我用到了字符类型的 padStart 方法,它传递两个参数,分别是数字最后要填充到这个指定的位数,以及用来填充的字符。


为了将 7 变成 07,我们需要将 number 类型的 7 变为字符串类型的 '7',然后执行 '7'.padStart(2, 0)。


除此之外,对于 AM 以及 PM 的区分,我们通过判断 getHours() 的返回值是否大等于 12。如果大于则为 PM,否则是 AM。


处理完数据之后通过修改 innerHTML 的值来改变页面上展现的时间,同时通过 setInterval 来不断执行该操作,实现实时更新时间的效果。


<script>
let hours = document.querySelector('#hours');
let minutes = document.querySelector('#minutes');
let seconds = document.querySelector('#seconds');
let ampm = document.querySelector('#ampm');

setInterval(() => {
let h = `${new Date().getHours() % 12}`.padStart(2, 0);
let m = `${new Date().getMinutes()}`.padStart(2, 0);
let s = `${new Date().getSeconds()}`.padStart(2, 0);
let am = h >= 12 ? 'PM' : 'AM';

hours.innerHTML = h + '\n<div class="tip">HOURS</div>';
minutes.innerHTML = m + '\n<div class="tip">MINUTES</div>';
seconds.innerHTML = s + '\n<div class="tip">SECONDS</div>';
ampm.innerHTML = am;
}, 1000);
</script>

注意点小结:



  1. getHours、getMinutes 以及 getSeconds 返回 number 类型的值(不带前缀 0)

  2. padStart 是字符类型的方法,注意先将类型转为 string 再进行调用。


我们来看看效果:


20221011_190750.gif


画圆


接下来我们要对每个时间的容器都画一个圆的效果,这里我使用了 svg 标签。原因下文会提。


有的小伙伴可能对 svg 标签比较陌生,确实平时开发的时候用的比较少,实际上它和我们普通的标签差不多,而且也能用过 CSS 设置它的一些属性。


这里画圆我们需要用到 circle 标签,其中,cxcy 属性共同确定了一个圆心的位置,r 属性表示待绘制圆的半径。


<div id="time">
<div class="circle" style="--clr: #ff2972">
<svg>
<circle cx="70" cy="70" r="70"></circle>
</svg>
<div id="hours">00</div>
</div>

<div class="circle" style="--clr: #fee800">
<svg>
<circle cx="70" cy="70" r="70"></circle>
</svg>
<div id="minutes">00</div>
</div>

<div class="circle" style="--clr: #04fc43">
<svg>
<circle cx="70" cy="70" r="70"></circle>
</svg>
<div id="seconds">00</div>
</div>

</div>

微信截图_20221011192308.png


可以看到默认情况下,circle 标签的背景色是黑色的,我们给它点样式。


#time .circle svg circle {
width: 100%;
height: 100%;
fill: transparent;
stroke: #191919;
stroke-width: 4;
}

fill 属性表示当前填充 circle 标签应当用什么颜色(实际上就是背景色的意思)。


stroke 属性表示绘制一个边线(实际上就是边框)。


stroke-width 属性一般搭配 stroke 属性一起用,表示边线的宽度。


微信截图_20221011192621.png


经过这么一手修改后已经有模有样了,但是别急,最麻烦的部分要来了。接下来我们要模拟时间进度条了。


模拟进度条


这里我们模拟进度条需要在每个 svg 标签下再添加一个 circle 标签。


<div id="time">
<div class="circle" style="--clr: #ff2972">
<svg>
<circle cx="70" cy="70" r="70"></circle>
<circle cx="70" cy="70" r="70" id="hh"></circle>
</svg>
<div id="hours">00</div>
</div>

<div class="circle" style="--clr: #fee800">
<svg>
<circle cx="70" cy="70" r="70"></circle>
<circle cx="70" cy="70" r="70" id="mm"></circle>
</svg>
<div id="minutes">00</div>
</div>

<div class="circle" style="--clr: #04fc43">
<svg>
<circle cx="70" cy="70" r="70"></circle>
<circle cx="70" cy="70" r="70" id="ss"></circle>
</svg>
<div id="seconds">00</div>
</div>

</div>

同时,通过 CSS 变量给这个新增的 circle 标签各不相同的颜色。


#time .circle svg circle:nth-child(2) {
stroke: var(--clr);
}

此时效果如下:


微信截图_20221011193127.png


接下来我们要用到一个新的属性:stroke-dasharray


我们来看看 MDN 对 stroke-dasharray 属性的介绍:



属性 stroke-dasharray 可控制用来描边的点划线的图案范式。



是不是有点懵,我们看看下面这张动图:


20221011_193806.gif


这是 stroke-dasharray 属性值从 0 开始不断增加的效果。那我们就知道了,实际上这个属性就是控制点划线的长度用的。


那它和我们的进度条有什么关系呢?


不要急,要实现我们的进度条,还需要另一个属性:stroke-dashoffset


我们来看看 MDN 对 stroke-dashoffset 属性的介绍:



属性 stroke-dashoffset 指定了 dash 模式到路径开始的距离。



话不多说,上图:


20221011_194553.gif


这是 stroke-dashoffset 属性值从 0 开始不断增加的效果,是不是很像进度条在跑?


我们就是通过 Javascript 动态修改 stroke-dashoffset 来达到进度条跟着时间一起跑的效果!


let hh = document.querySelector('#hh');
let mm = document.querySelector('#mm');
let ss = document.querySelector('#ss');

setInterval(() => {
...
hh.style.strokeDashoffset = 440 - (440 * h) / 12;
mm.style.strokeDashoffset = 440 - (440 * m) / 60;
ss.style.strokeDashoffset = 440 - (440 * s) / 60;
}, 1000);

20221011_195356.gif


码上掘金


SumXiMRX - 码上掘金 (juejin.cn)


Github 源码地址


juejin-demo/digital-clock-demo at main · catwatermelon/juejin-demo (github.com)


结束语


本文就到此结束了,希望大家共同努力,早日拿下 CSS 💪💪。


如果文中有不对的地方,或是大家有不同的见解,欢迎指出 🙏🙏。


如果大家觉得所有收获,欢迎一键三连💕💕。


作者:CatWatermelon
来源:juejin.cn/post/7153836297218424863
收起阅读 »

原来Promise 还可以这样用?

web
举个例子 需求 组件b初始化某个用到的库,只有在初始化完成后才能调用其API,不然会报错。a页面负责调用 上代码 // a.vue <template> <div> 这是a页面 <childB ref="chi...
继续阅读 »

举个例子


需求


组件b初始化某个用到的库,只有在初始化完成后才能调用其API,不然会报错。a页面负责调用


上代码


// a.vue
<template>
<div>
这是a页面
<childB ref="childB" />
</div>

</template>
<script>
import childB from './b'
export default {
mounted() {
setTimeout(() => {
this.$refs.childB.play()
}, 3000)
},
components: {
childB,
},
}
</script>

// b.vue
<template>
<div>这是b页面</div>
</template>

<script>
export default {
data() {
return {
flag: false,
}
},
created() {
this.init()
},
methods: {
init() {
setTimeout(() => {
this.flag = true
}, 2000)
},
play() {
if (!this.flag) return console.log('not init')
console.log('ok')
},
},
}
</script>



以上代码为模拟初始化,用setTimeout代替,实际开发中使用是一个回调函数,那么我页面a也是用setTimeout?写个5秒?10秒?有没有解决方案呢?


解决方案


那肯定是有的,我们可以这样写……


// a.vue
<template>
<div>
这是a页面
<childB ref="childB" />
</div>

</template>
<script>
import childB from './b'
export default {
mounted() {
this.init()
},
methods: {
init() {
setTimeout(() => {
this.$refs.childB.play()
}, 2000)
},
},
components: {
childB,
},
}
</script>

// b.vue
<template>
<div>这是b页面</div>
</template>

<script>
export default {
methods: {
play() {
console.log('ok')
},
},
}
</script>


相信这也是最常见也是大多数人使用的方案了,但是我觉得把b组件中的代码写到了a页面中,假如有多个b组件,那么a页面中要写多好的b组件代码。容易造成代码混淆、冗余,发生异常的错误,阻塞进程,这显然是不能接受的。


思考


我们能不能用promise来告诉我们是否已经完成初始呢?


答案当然是可以的!


下面我们改造一下代码


// a.vue
<template>
<div>
这是a页面
<childB ref="childB" />
</div>

</template>
<script>
import childB from './b'
export default {
mounted() {
const { init, play } = this.$refs.childB
init().then(play)
},
components: {
childB,
},
}
</script>

// b.vue
<template>
<div>这是b页面</div>
</template>

<script>
export default {
methods: {
init() {
return new Promise(resolve => {
setTimeout(() => {
resolve()
}, 2000)
})
},
play() {
console.log('ok')
},
},
}
</script>


嗯~ o( ̄▽ ̄)o 果然nice,干净整洁,一气呵成!


不足


init在a页面mounted时候才触发,感觉太晚了。能不能在b组件created时候自行触发呢?


哈哈,当然可以了!


我们再改造一下代码


// a.vue
<template>
<div>
这是a页面
<childB ref="childB" />
</div>

</template>
<script>
import childB from './b'

export default {
mounted() {
this.$refs.childB.play()
},
components: {
childB,
},
}
</script>

// b.vue
<template>
<div>这是b页面</div>
</template>

<script>
function getPromiseWait() {
let success, fail
const promise = new Promise((resolve, reject) => {
success = resolve
fail = reject
})
return { promise, resolve: success, reject: fail }
}
const { promise, resolve } = getPromiseWait()
export default {
created() {
this.init()
},
methods: {
init() {
setTimeout(() => {
resolve('hello')
}, 2000)
},
async play() {
const res = await promise
console.log('ok', res)
},
},
}
</script>



完美


我们在b组件中生成一个promise来控制是否init完成,a页面只需要直接调用b组件的play方法即可。如有需要还可以在resolve传递参数,通过then回调函授拿到数据,Pro

作者:𝓼𝓹𝓻𝓲𝓽𝓮𝓐𝓹𝓮
来源:juejin.cn/post/7225127360445841466
mise YYDS!

收起阅读 »

WEB前端奇淫巧计-消除异步的传染性

web
简介 大家好今天给大家介绍一个关于异步的比较恶心的东西也许大家在开发中也曾遇到过只不过解决起来比较棘手废话不多说直接上代码 async function getUser() { return await fetch('https://my-json-ser...
继续阅读 »


简介


大家好
今天给大家介绍一个关于异步的比较恶心的东西
也许大家在开发中也曾遇到过
只不过解决起来比较棘手
废话不多说直接上代码


async function getUser() {
return await fetch('https://my-json-server.typicode.com/typicode/demo/profile').then((resp) => resp.json())
}

async function m1(){
//other works
return await getUser()
}

async function m2(){
//other works
return await m1()
}

async function m3(){
//other works
return await m2()
}

async function main() {
const res = await m3()
console.log('res', res)
}
main()

经过观察上述代码有没有发现
一旦一个函数使用 async await
其他函数调用这个函数进行异步操作时,也要加上async await
突然有没有觉得有那么一丝丝小恶心
我们今天的目的就是把以上的async await去掉也能达到同样的效果


function getUser() {
return fetch('https://my-json-server.typicode.com/typicode/demo/profile')
}

function m1() {
//other works
return getUser()
}

function m2() {
//other works
return m1()
}

function m3() {
//other works
return m2()
}

function main() {
const res = m3()
console.log('res', res)
}
main()

就像以上代码调用,也能实现同样的效果
是不是一下子有点懵懵的
这其实是一个大厂的内部晋升题,还是有点小难度的
这个问题在一些框架的底层也会常遇到
我来带你逐步探讨


解决问题


不难发现通过以上直接去掉async await是无法得到原来的结果的
因为它会返回一个promise 对象,无法使res得到真实的数据
这里我先说一下大概思路
首先fetch会返回一个promise,但是在请求时就想对结果进行操作,显然是不可能的
这时候我们需要在fetch没返回我们想要的数据前先终止函数运行,等拿到正确的数据后我们再运行函数
是不是听到这个过程也是一头雾水呀
先别着急
继续往下看
如果想要函数终止运行有个办法那就是抛出异常 throw error
然后等fetch返回数据data后,对数据进行缓存
缓存后开始函数的运行,
最后交付data
看一下流程图
image.png
整体流程大概就是这样
为了方便理解,我化简一下上述代码


function main() {
const res = fetch('https://my-json-server.typicode.com/typicode/demo/profile')
console.log('res', res)//res要得到一个data数据而不是一个promise对象
}
main()

我们都知道fetch实际返回一个promise对象
此时返回的是一个promise
image.png
在不改变main函数体的情况下使得res是我们想要的数据而不是promise
下面是我们想要的数据
image.png
那我们就得想办法更改main的调用方式


function main() {
const res = fetch('https://my-json-server.typicode.com/typicode/demo/profile')
console.log('res', res)//res要得到一个data数据而不是一个promise对象
}
function run(func){
//瓜瓜一顿操作,使得fetch返回真实的数据而不是promise
}
run(main)

根据上述讲的流程,我们来看一下run函数的具体过程
注释我已经写的很详细了
大家认真看哦


function run(func) {
let cache = []//缓存的列表,由于可能不止一个fetch,所以要用一个list
let i = 0;//缓存列表的下标
const _originalFetch = window.fetch//储存原先的fetch
window.fetch = (...args) => {//重写fetch函数,这个fetch要么抛出异常,要么返回真实的数据
if (cache[i]) {//判断一下缓存是否存在,如果存在就返回真实的数据或抛出异常
if (cache[i].status === 'fulfilled') {
return cache[i].data
} else if (cache[i].status === 'rejected') {
throw cache[i].err
}
}
const result = {
status: 'pending',
data: null,
err: null
}
cache[i++] = result//添加缓存
//发送请求
//真实的fetch调用
const prom = _originalFetch(...args).then(resp => resp.json()).then(resp => {
//等待返回结果,然后修改缓存
result.status = 'fulfilled'
result.data = resp
}, err => {
result.status = 'rejected'
result.data = err
})
//如果没有缓存,就添加缓存和抛出异常
throw prom
//这里为什么会抛出真实fetch返回的promise,主要是因为外面会用到这个promise然后等待拿到最终结果
}
try {
//在try里调用func也就是上述的main函数
//由于main里面有fetch,且第一次没有缓存,所以会抛出一个异常
func()

} catch (err) {
//从这里捕获到异常
//这里的err就是上述fetch返回的promise

if (err instanceof Promise) {//验证一下是不是promise
const reRun = () => {
i = 0//重置一下下标
func()
}
err.then(reRun, reRun)//待promise返回结果后重新执行func,也就是重新执行main
//这次执行已经有缓存了,并且返回中有了正确的结果,所以重写的fetch会返回真实的数据
}
}
}

通过这么一个函数调用main,就可以使得在不改变main函数体的情况下使得fetch返回真实的数据而不是promise对象
是不是感到很神奇
我们来看下完整代码


function getUser() {
return fetch('https://my-json-server.typicode.com/typicode/demo/profile')
}

function m1() {
//other works
return getUser()
}

function m2() {
//other works
return m1()
}

function m3() {
//other works
return m2()
}

function main() {
const res = m3()
console.log('res', res)
}

function run(func) {
let cache = []//缓存的列表
let i = 0;//缓存下标
const _originalFetch = window.fetch//储存原先的fetch
window.fetch = (...args) => {//重写fetch函数
if (cache[i]) {
if (cache[i].status === 'fulfilled') {
return cache[i].data
} else if (cache[i].status === 'rejected') {
throw cache[i].err
}
}
const result = {
status: 'pending',
data: null,
err: null
}
cache[i++] = result
//发送请求
const prom = _originalFetch(...args).then(resp => resp.json()).then(resp => {
result.status = 'fulfilled'
result.data = resp
}, err => {
result.status = 'rejected'
result.data = err
})
throw prom
}
try {
func()
} catch (err) {
//什么时候引发重新执行function
if (err instanceof Promise) {
const reRun = () => {
i = 0
func()
}
err.then(reRun, reRun)
}
}
}
run(main)

此时执行的结果,就是我们想要的结果
image.png
没错就是这样,nice



在框架中的应用


其实在react这个应用很常见
我们先来看一段代码


const userResource = getUserResource()
function ProfilePage() {
return (
<Suspense fallback={<h1>Loading profile...</h1>}>
<ProfileDetails />
</Suspense>

)
}
function ProfileDetails(){
const user = userResource.read();
return <h1>{user.name}</h1>
}
ReactDOM.render(<ProfilePage/>, document.getElementById("root"));

别急别急我来稍微翻译下
这段代码的意思是在ProfileDetails没加载到数据前先显示Loading profile...
待ProfileDetails加载到数据就渲染 {user.name}
他是怎么实现的呢
如果放在vue里面ProfileDetails必须为一个异步函数
而在这里的实现方案与我上述讲述的类似
我们来验证一下
在ProfileDetails打印1


function ProfileDetails(){
console.log(1)//在这里输出一个1
const user = userResource.read();
return <h1>{user.name}</h1>
}

输出结果是这样的
image.png
为什么会输出两个1呢
原因就和我们上述代码类似
在userResource.read()第一次执行它会抛出一个错误
第二次是已经拿到数据
所以它执行了两遍,最终拿到了数据
我们在函数里手动抛出一个promise


function ProfileDetails(){
throw new Promise((resolve)=>{})//我们在这里抛出一个promise,且函数体里没有执行resolve()
const user = userResource.read();
return <h1>{user.name}</h1>
}

你会发现页面一直展示Loading profile...
image.png
因为我们抛出的promise,一直没有resolve,也就是等待不了结果返回,所以它只会渲染Loading profile...保持不变
肿么样,神奇吧,你学费了嘛
有兴趣的可以一起学习交流,有什么问题也可以联系我
小编微信:buouyupro


作者:布偶鱼
来源:juejin.cn/post/7223937161707716669
收起阅读 »

前端枚举最佳规范——优雅可能也会过时

web
痛点很久很久以前,我在ts项目中使用枚举是这样的export enum GENDER {      MALE = 1,      FEMALE = 2,  }export const GEN...
继续阅读 »

痛点

很久很久以前,我在ts项目中使用枚举是这样的

export enum GENDER {  
   MALE = 1,  
   FEMALE = 2,  
}

export const GENDER_MAP: Record<GENDER, string> = {  
  [GENDER.MALE]: '男',  
  [GENDER.FEMALE]: '女',  
}

// 可能还会写一个给select组件使用的options
export const GENDER_OPTIONS = [  
  {  
       label: '男',  
       value: GENDER.MALE  
  },  
  {  
       label: '女',  
       value: GENDER.FEMALE,  
  }  
];

封装

淦!好麻烦。封装一下,暂时只封装了一个js版本的,想做成ts版本的请自行更改

import { invert, isArray } from 'lodash';

class Enum {
 constructor(enumsName) {
   this.enumsName = enumsName;
   this.enums = {};
}
 // 设置枚举项
 setItem(desc, value) {
   this.enums[desc] = value;
   return this;
}
 findEnumItem(value) {
   return Object.keys(this.enums).find(
    (desc) => this.getValueFromDesc(desc) === value,
  );
}
 // 根据值获取描述
 getValueFromDesc(desc) {
   return this.enums[desc];
}
 getDescriptionFromValue(value, separator = ',') {
   if (isArray(value)) {
     return value.map((item) => this.findEnumItem(item)).join(separator);
  } else {
     return this.findEnumItem(value);
  }
}
 // 获取枚举第一项的值
 getFirstValue() {
   const enums = this.getEnums();
   return enums[Object.keys(enums)[0]];
}
 // 自定义转换枚举数组格式
 transformEnums(formatTarget) {
   // formatTarget 数组第一项是描述属性名称,第二项是枚举值属性名称
   if (isArray(formatTarget) && formatTarget.length === 2) {
     const [keyName, valueName] = formatTarget;
     return Object.entries(this.enums).map((item) => {
       const [desc, value] = item;
       return {
        [keyName]: desc,
        [valueName]: value,
      };
    });
  } else {
     return [];
  }
}
 // 获取 options
 getOptions() {
   return Object.entries(this.enums).map((item) => {
     const [desc, value] = item;
     return {
       label: desc,
       value,
    };
  });
}
 // 获取描述和值反转对象,输出 {value: desc}
 getInvertEnums() {
   return invert(this.enums);
}
 is(enumsName) {
   return this.enumsName === enumsName;
}
}
export default Enum;

export const getEnums = (enumsName, enums) =>
 enums.find((enumItem) => enumItem.is(enumsName));

使用

ok,咋使用呢?首先当然要创建枚举啦

// commonEnum.js
import Enum from '@/utils/enum';

// 我习惯把同一个模块或功能中的枚举全都塞到一个数组中
export const COMMON_ENUMS = [
   new Enum('性别').setItem('男', 1).setItem('女', 2),
   ...
];

在使用到的地方,先获取你想要的枚举

import {getEnums} from '@/utils/enum';
import {COMMON_ENUMS} from '@/enum/commonEnum';

const genderEnums = getEnums('性别', COMMON_ENUMS);

接下来分一些场景来举例一些使用方法:

  1. 作某个字段的值映射

{
   title: '性别',  
   dataIndex: 'gender',  
   render: (gender) => genderEnums.getDescriptionFromValue(gender),
}
  1. select组件中需要传入选项

<Select  
   name="gender"  
   label="性别"
   options={genderEnums.getOptions}
/>

其余方法就留给大家自己探索吧,我觉得这个封装已经可以涵盖大部分的场景了,你觉得呢?

作者:AliPaPa
来源:juejin.cn/post/7221820151397335077

收起阅读 »

前端实现点击选词功能

web
今天有一个需求,点击选中某个英文单词,然后对这个单词做一些处理,例如高亮背景、查看一些详细信息等等,今天简单实现了一下,效果如下:(支持移动端,chrome和sarafi浏览器均能正常使用。语言🚀 vue3 + typescript) 选词 由于要动态添加给...
继续阅读 »

今天有一个需求,点击选中某个英文单词,然后对这个单词做一些处理,例如高亮背景、查看一些详细信息等等,今天简单实现了一下,效果如下:(支持移动端,chrome和sarafi浏览器均能正常使用。语言🚀 vue3 + typescript)


highlight.gif


选词


由于要动态添加给某些单词动态添加一些标签,我们这里可以考虑使用v-html


首先我们先编写一下简单的结构


<script setup lang="ts">
</script>

<template>
<div class="container" v-html="shortArticle"></div>
</template>


<style>
.container {
font-size: 18px;
}
</style>

然后,我们将需要处理的短文变换为span标签包裹,这里的思路是按照空格划分,然后添加span结构,最后拼接到一起返回。这里有一些边缘条件要考虑,比如can't(whichyes!等等,按照空格划分出来的数据有一点问题。


截屏2023-04-19 20.48.19.png


如果不做处理的话,一些标点符号也会高亮出来,就不太正确了。下面是处理逻辑,整体比较简单,就不解释了。


function addElementSpan(str: string): string {
return str
.split(' ')
.map((item) => {
const { start, word, end } = getWord(item)
return `${start}<span>${word}</span>${end} `
})
.join('')
}

function getWord(str: string) {
let word = ''
let start = ''
let end = ''
let j = str.length - 1
let i = 0

while (i < str.length) {
if (/^[a-zA-Z]$/.test(str[i])) {
break
}
start = start + str[i]
i += 1
}

while (j >= 0) {
if (/^[a-zA-Z]$/.test(str[j])) {
break
}
end = str[j] + end
j -= 1
}

word = str.slice(i, j + 1)

// 处理数字
if (!word && start === end) {
start = ''
}

return {
start,
word,
end
}
}

现在我们来实现效果


<script setup lang="ts">
import { computed } from 'vue'
import { addElementSpan } from './utils'

const str = `It works fine if you move the navbar outside the header. See below. For the reason, according to MDN: The element is positioned according to the normal flow of the document, and then offset
relative to its flow root and containing block based on the values of top, right, bottom, and
left. For the containing block: The containing block is the ancestor to which the element is
relatively positioned So, when I do not misunderstand, the navbar is positioned at offset 0
within the header as soon as it is scrolled outside the viewport (which, clearly, means, you
can't see it anymore).`


const shortArticle = computed(() => {
return addElementSpan(str)
})

function setColor(event: any) {
// console.log(event.target.innerText) 获取选中的文本
event.target?.classList.add('word_highlight')
}
</script>

<template>
<div class="container" @click="setColor($event)" v-html="shortArticle"></div>
</template>


<style>
.word_highlight {
background-color: red;
}
</style>


在父亲元素上添加点击事件,触发事件点击之后,调用setColor函数,高亮背景(添加class)


不过有一点小小的问题,点击div的空白区域或者非英文单词区域会直接整个背景变成红色,控制台打印event.target.innerText可以发现它的值为整个文本,所以我们可以根据判断打印的文本长度和需要设置的文本长度是否一致来解决这个问题。(ps:⬆️面的示例代码str字符串使用了反引号 模板字符串 ,直接使用下面会影响结果)


function setColor(event: any) {
// console.log(event.target.innerText)
if(str !== event.target.innerText){
event.target?.classList.add('word_highlight')
}
}

对于event.target不太了解的伙伴可以看这篇文章 ➡️ Event.target - Web API 接口参考 | MDN (mozilla.org)


(和event.target类似的还有一个属性event.currentTarget,不太了解的伙伴可以看下这篇文章 ➡️ Event.currentTarget - Web API 接口参考 | MDN (mozilla.org),它俩的区别是event.target指的是事件触发的元素,而event.currentTarget指的是事件绑定的元素)


功能拓展


这里只是演示了一下比较简单的背景高亮效果,有需求的伙伴可以自己拓展一下。


比如类似于掘金的拼写错误提示框


截屏2023-04-19 21.16.20.png


如果要实现滑动选词的话,可以参考这个博主的文章 ➡️ 鼠标选中文本划词高亮、再次选中划词取消高亮效果


作者:笨笨狗吞噬者
来源:juejin.cn/post/7223733256688025661
收起阅读 »

因为写不出拖拽移动效果,我恶补了一下Dom中的各种距离

web
背景 最近在项目中要实现一个拖拽头像的移动效果,一直对JS Dom拖拽这一块不太熟悉,甚至在网上找一个示例,都看得云里雾里的,发现遇到最大的拦路虎就是JS Dom各种各样的距离,让人头晕眼花,看到一个距离属性,大脑中的印象极其模糊,如同有一团雾一样,不知其确切...
继续阅读 »

背景


最近在项目中要实现一个拖拽头像的移动效果,一直对JS Dom拖拽这一块不太熟悉,甚至在网上找一个示例,都看得云里雾里的,发现遇到最大的拦路虎就是JS Dom各种各样的距离,让人头晕眼花,看到一个距离属性,大脑中的印象极其模糊,如同有一团雾一样,不知其确切含义。果然是基础不牢,地动山摇。今天决心夯实一下基础,亲自动手验证一遍dom各种距离的含义。


JS Dom各种距离释义


下面我们进入正题, 笔者不善于画图, 主要是借助浏览器开发者工具,通过获取的数值给大家说明一下各种距离的区别。


第一个发现 window.devicePixelRatio 的存在


本打算用截图软件丈量尺寸,结果发现截图软件显示的屏幕宽度与浏览器开发者工具获取的宽度不一致,这是为什么呢?



  • 截图软件显示的屏幕宽度是1920


image.png



  • window.screen.width显示的屏幕宽度是1536


image.png


这是怎么回事?原来在PC端,也存在一个设备像素比的概念。它告诉浏览器一个css像素应该使用多少个物理像素来绘制。要说设备像素比,得先说一下像素和分辨率这两个概念。



  • 像素
    屏幕中最小的色块,每个色块称之为一个像素(Pixel)


image.png



image.png



  • 设备像素比


设备像素比的定义是:


window.devicePixelRatio =显示设备物理像素分辨率显示设备CSS像素分辨率\frac{显示设备物理像素分辨率}{显示设备CSS像素分辨率}


根据设备像素比的定义, 如果知道显示设备横向的css像素值,根据上面的公式,就能计算出显示设备横向的物理像素值。


显示设备宽度物理像素值= window.screen.width * window.devicePixelRatio;

设备像素比在我的笔记本电脑上显示的数值是1.25, 代表一个css逻辑像素对应着1.25个物理像素。


image.png


我前面的公式计算了一下,与截图软件显示的像素数值一致。这也反过来说明,截图软件显示的是物理像素值。


image.png



  • window.devicePixelRatio 是由什么决定的 ?


发现是由笔记本电脑屏幕的缩放设置决定的,如果设置成100%, 此时window.screen.width与笔记本电脑的显示器分辨率X轴方向的数值一致,都是1920(如右侧图所示), 此时屏幕上的字会变得比较小,比较伤视力。





  • 逻辑像素是为了解决什么问题?


逻辑像素是为了解决屏幕相同,分辨率不同的两台显示设备, 显示同一张图片大小明显不一致的问题。比如说两台笔记本都是15英寸的,一个分辨率是1920*1080,一个分辨率是960*540, 在1920*1080分辨率的设备上,每个格子比较小,在960*540分辨率的设备上,每个格子比较大。一张200*200的图片,在高分率的设备上看起来会比较小,在低分辨率的设备上,看起来会比较大。观感不好。为了使同样尺寸的图片,在两台屏幕尺寸一样大的设备上,显示尺寸看起来差不多一样大,发明了逻辑像素这个概念。规定所有电子设备呈现的图片等资源尺寸统一用逻辑像素表示。然后在高分辨率设备上,提高devicePixelRatio, 比如说设置1920*1080设备的devicePixelRatio(dpr)等于2, 一个逻辑像素占用两个格子,在低分辨率设备上,比如说在960*540设备上设置dpr=1, 一个css逻辑像素占一个格子, 这样两张图片在同样的设备上尺寸大小就差不多了。通常设备上的逻辑像素是等于物理像素的,在高分辨率设备上,物理像素是大于逻辑像素数量的。由此也可以看出,物理像素一出厂就是固定的,而设备的逻辑像素会随着设备像素比设置的值不同而改变。但图片的逻辑像素值是不变的。


document.body、document.documentElement和window.screen的宽高区别


差别是很容易辨别的,如下图所示:



  • document.body -- body标签的宽高

  • document.documentElement -- 网页可视区域的宽高(不包括滚动条)

  • window.screen -- 屏幕的宽高


image.png



  • 网页可视区域不包括滚动条


如下图所示,截图时在未把网页可视区域的滚动条高度计算在内的条件下, 截图工具显示的网页可视区域高度是168, 浏览器显示的网页可视区域的高度是167.5, 误差0.5,由于截图工具是手动截图,肯定有误差,结果表明,网页可视区域的高度 不包括滚动条高度。宽度同理。


image.png



  • 屏幕和网页可视区域的宽高区别如下:


屏幕宽高是个固定值,网页可视区域宽高会受到缩放窗口影响。


image.png



  • 屏幕高度和屏幕可用高度区别如下:


屏幕可用高度=屏幕高度-屏幕下方任务栏的高度,也就是:


window.screen.availHeight = window.screen.height - 系统任务栏高度

image.png


scrollWidth, scrollLeft, clientWidth关系


scrollWidth(滚动宽度,包含滚动条的宽度)=scrollLeft(左边卷去的距离)+clientWidth(可见部分宽度);
// 同理
scrollHeight(滚动高度,包含滚动条的高度)=scrollTop(上边卷去的距离)+clientHeight(可见部分高度);

需要注意的是,上面这三个属性,都取的是溢出元素的父级元素属性。而不是溢出元素本身。本例中溢出元素是body(document.body),其父级元素是html(document.documentElement)。另外,


溢出元素的宽度(document.body.scrollWidth)=父级元素的宽度(document.documentElement.scrollWidth) - 滚动条的宽度(在谷歌浏览器上滚动条的宽度是19px)

image.png


<!DOCTYPE html>
<html lang="en">

<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<!-- <meta name="viewport" content="width=device-width, initial-scale=1.0"> -->
<title>JS Dom各种距离</title>
<style>
html,
body {
margin: 0;
}

body {
width: 110%;
border: 10px solid blue;
}

.rect {
height: 50px;
background-color: green;
}
</style>
</head>

<body>
<div id="rect" class="rect"></div>
</body>

</html>

元素自身和父级元素的scrollWidth和scrollLeft关系?


从下图可以看出:



  • 元素自身没有X轴偏移量,元素自身的滚动宽度不包含滚动条

  • 父级元素有X轴便宜量, 父级元素滚动宽度包含滚动条
    image.png


<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<!-- <meta name="viewport" content="width=device-width, initial-scale=1.0"> -->
<title>JS Dom各种距离</title>
<style>
div {
border: 1px solid #000;
width: 200px;
height: 600px;
padding: 10px;
background-color: green;
margin: 10px;
}
</style>
</head>

<body>
<div class="rect"> 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
</div>
</body>
<script>
</script>
</html>

offsetWidth和clientWidth的关系?


offsetWidth和clientWidth的共同点是都包括 自身宽度+padding , 不同点是offsetWidth包含border


如下图所示:



  • rect元素的clientWidth=200px(自身宽度) + 20px(左右padding) = 220px

  • rect元素的offsetWidth=200px(自身宽度) + 20px(左右padding) + 2px(左右boder) = 222px


image.png


<!DOCTYPE html>
<html lang="en">

<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<!-- <meta name="viewport" content="width=device-width, initial-scale=1.0"> -->
<title>JS Dom各种距离</title>
<style>
div {
border: 1px solid #000;
width: 200px;
height: 100px;
padding: 10px;
background-color: green;
margin: 10px;
}
</style>
</head>

<body>
<div class="rect">111111111111111111111111111111111111111111111111</div>
</body>
<script>


</script>

</html>

event.clientX,event.clientY, event.offsetX 和 event.offsetY 关系


代码如下,给rect元素添加一个mousedown事件,打印出事件源的各种位置值。


<!DOCTYPE html>
<html lang="en">

<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<!-- <meta name="viewport" content="width=device-width, initial-scale=1.0"> -->
<title>JS Dom各种距离</title>
<style>
html,
body {
margin: 0;
}

body {
width: 200px;
padding: 10px;
border: 10px solid blue;
}

.rect {
height: 50px;
background-color: green;
}
</style>
</head>

<body>

<div id="rect" class="rect"></div>


</body>
<script>
const rectDom = document.querySelector('#rect');

rectDom.addEventListener('mousedown', ({ offsetX, offsetY, clientX, clientY, pageX, pageY, screenX, screenY }) => {
console.log({ offsetX, offsetY, clientX, clientY, pageX, pageY, screenX, screenY });
})
</script>

</html>

我们通过y轴方向的高度值,了解一下这几个属性的含义。 绿色块的高度是50px, 我们找个特殊的位置(绿色块的右小角)点击一下,如下图所示:



  • offsetY=49, 反推出这个值是相对于元素自身的顶部的距离

  • clientY=69, body标签的border-top是10,paiding是10, 反推出这个值是相对网页可视区域顶部的距离

  • screenY=140,目测肯定是基于浏览器窗口,


所以它们各自的含义,就很清楚了。


image.png


事件源属性表示的距离
event.offsetX、event.offsetY鼠标相对于事件源元素(srcElement)的X,Y坐标,
event.clientX、event.clientY鼠标相对于浏览器窗口可视区域的X,Y坐标(窗口坐标),可视区域不包括工具栏和滚动偏移量。
event.pageX、event.pageY鼠标相对于文档坐标的x,y坐标,文档坐标系坐标 = 视口坐标系坐标 + 滚动的偏移量
event.screenX、event.screenY鼠标相对于用户显示器屏幕左上角的X,Y坐标


  • pageX和clientX的关系


我们点击下图绿色块的右下角,把pageX和clientX值打印出来。如下图所示:



  • 可视区域的宽度是360,点击点的clientX=359(由于是手动点击,有误差也正常)

  • 水平方向的偏移量是56

  • pageX是415,360+56=416,考虑到点击误差,可以推算出 ele.pageX = ele.clientX + ele.scrollLeft


image.png


getBoundingClientRect获取的top,bottom,left,right的含义


从下图可以看出,上下左右这四个属性,都是相对于浏览器可视区域左上角而言的。



从下图可以看出,当有滚动条出现的时候,right的值是359.6,而不是360+156(x轴的偏移量), 说明通过getBoundingClientRect获取的属性值是不计算滚动偏移量的,是相对浏览器可视区域而言的。


image.png


想移动元素,mouse和drag事件怎么选?


mouse事件相对简单,只有mousedown(开始),mousemove(移动中),mouseup(结束)三种。与之对应的移动端事件是touch事件,也是三种touchstart(手指触摸屏幕), touchmove(手指在屏幕上移动), touchend(手指离开屏幕)。


相对而言, drag事件就要丰富一些。



  • 被拖拽元素事件


事件名触发时机触发次数
dragstart拖拽开始时触发一次1
drag拖拽开始后反复触发多次
dragend拖拽结束后触发一次1


  • 目标容器事件


事件名触发时机触发次数
dragenter被拖拽元素进入目标时触发一次1
dragover被拖拽元素在目标容器范围内时反复触发多次
drop被拖拽元素在目标容器内释放时(前提是设置了dropover事件)1

想要移动一个元素,该如何选择这两种事件类型呢? 选择依据是:


类型选择依据
mouse事件1. 要求丝滑的拖拽体验 2. 无固定的拖拽区域 3. 无需传数据
drag事件1. 拖拽区域有范围限制 2. 对拖拽流畅性要求不高 3. 拖拽时需要传数据

现在让我们写个拖拽效果


光说不练假把式, 扫清了学习障碍后,让我们自信满满地写一个兼容PC端和移动端的拖动效果。不积跬步无以至千里,幻想一口吃个胖子,是不现实的。这一点在股市上体现的淋漓尽致。都是有耐心的人赚急躁的人的钱。所以,要我们沉下心来,打牢基础,硬骨头啃一点就会少一点,步步为营,稳扎稳打,硬骨头也会被啃成渣。



<!DOCTYPE html>
<html lang="en">
<head>
    
<meta charset="UTF-8" />
    
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
    
<title>拖拽水潭</title>
<style>
.water {
position: absolute;
width: 100px;
height: 100px;
border-radius: 100px;
cursor: grab;
z-index: 10;
}
</style>
</head>

<body>
<img class="water" src="./water.png" alt="" />  
</body>

<script>
let evtName = getEventName();
// 确保图片加载完
window.onload = () => {
// 鼠标拖拽图片时,拖拽点距离图片X和Y轴方向的距离
let offsetX = 0, offsetY = 0;
const water = document.querySelector(".water");

const moveAt = ({ pageX, pageY }) => {
water.style.cssText = `left:${pageX - offsetX}px;top:${pageY - offsetY}px;`;
};

water.addEventListener(evtName.start, (event) => {
// 图片的偏移距离是针对图片边界, 不能把图片边界到鼠标点击图片位置的距离算在内
// 否则移动图片结束后,就会出现向下,向右非自然的偏移
offsetX = event.clientX - water.getBoundingClientRect().left;
offsetY = event.clientY - water.getBoundingClientRect().top;

// 设置初始偏移
moveAt(event);

// 监听鼠标相对于可视窗口移动的距离
document.addEventListener(evtName.move, moveAt);
});

// 拖动停止时,释放document上绑定的移动事件
// 不然移动鼠标,不拖拽时白白产生性能开销
water.addEventListener(evtName.end, () =>
document.removeEventListener(evtName.move, moveAt);
});
};

// 区分是移动端还是PC端移动事件
function getEventName() {
if ("ontouchstart" in window) {
return {
start: "touchstart",
move: "touchmove",
end: "touchend",
};
} else {
return {
start: "mousedown",
move: "mousemove",
end: "mouseup",
};
}
}
</script>
</html>

彩蛋


在chrome浏览器上发现一个奇怪的现象,设置的border值是整数,计算出来的值却带有小数


image.png


而当border值是4的整数倍的时候,计算值是正确的


image.png


看了这篇文章解释说,浏览器可能只能渲染具有整数物理像素的border值,不是整数物理像素的值时,计算出的是近似border值。这个解释似乎讲得通,在设备像素比是window.devicePixelRatio=1.25的情况下, 1px对应的是1.25物理像素, 1.25*4的倍数才是整数,所以设置的逻辑像素是4的整数倍数,显示的渲染计算值与设置值一致,唯一让人不理解的地方,为什么padding,margin,width/height却不遵循同样的规则。


作者:去伪存真
来源:juejin.cn/post/7225206098692407355
收起阅读 »

让我看看你们公司的代码规范都是啥样的?

web
我这里提供一份我自己在使用的项目代码规范,当然我这里比较简陋,有补充的可以打在评论区,我丰富到文章里去。 1.组件命名规范 components下的组件命名规范遵循大驼峰命名规范。 示例:conpnents/AlbumItemCard/AlbumItemCar...
继续阅读 »

我这里提供一份我自己在使用的项目代码规范,当然我这里比较简陋,有补充的可以打在评论区,我丰富到文章里去。


1.组件命名规范


components下的组件命名规范遵循大驼峰命名规范。


示例:conpnents/AlbumItemCard/AlbumItemCard.vue



小驼峰式命名法(lower camel case): 第一个单词以小写字母开始;第二个单词的首字母大写,例如:myName




大驼峰式命名法(upper camel case): 每一个单字的首字母都采用大写字母,例如:MyName



2.目录命名规范


pages下的文件命名规范:遵循小驼峰命名规范。


示例:pages/createAlbum/createAlbum.vue


3.CSS命名规范


class命名规范为中划线。


示例:


<template>
<view class="gui-padding">
...
</view>
</template>
<style lang="scss" scoped>
.gui-padding {
...
}
</style>

css使用scss进行书写。


4.代码注释规范


行内注释://


函数注释:


/**
* @description: 加深颜色值
* @param {string} color 颜色值字符串
* @returns {*} 返回处理后的颜色值
*/

export function getDarkColor(color: string, level: number) {
const reg = /^#?[0-9A-Fa-f]{6}$/
if (!reg.test(color)) return ElMessage.warning('输入错误的hex颜色值')
const rgb = hexToRgb(color)
for (let i = 0; i < 3; i++)
rgb[i] = Math.round(20.5 * level + rgb[i] * (1 - level))
return rgbToHex(rgb[0], rgb[1], rgb[2])
}

接口注释:


/**
* @description 获取后台用户分页列表(带搜索)
* @param page
* @param limit
* @param username
* @returns {<PageRes<AclUser.ResAclUserList>>}
* @docs https://xxxx
*/

export function getAclUserList(params: AclUser.ReqAclUserListParams) {
return http.get<PageRes<AclUser.ResAclUserList>>(
`/admin/acl/user/${params.pageNum}/${params.pageSize}`,
{ username: params.username },
)
}

5.接口书写规范


4.1 接口定义规范:


接口全部写在api目录下面,按照功能划分,分为不同的目录。


比如搜索接口,定义在api/search/index.ts下面。


4..2 接口书写规范:


统一使用类方法,内部方法定义每个接口,最后统一export,接口使用到的类型全部定义在同级目录的interfaces.ts文件中。比如搜索相关的接口:


import Service from '../../utils/request'
import { SearchItemInterface, SearchPageResponseInterface, SearchParamsInterface } from "./interfaces"

class CateGory extends Service {

/**
* @description 搜索功能
* @param {SearchParamsInterface} params 二级分类Id
*/

// 搜索
getSearchAlbumInfo(params: SearchParamsInterface) {
return this.post<SearchPageResponseInterface<SearchItemInterface[]>>({
url: '/api/search/albumInfo',
data: params
})
}
/**
* @description: 获取搜索建议
* @param {string} keyword 搜索关键字
* @return {*}
*/

getSearchSuggestions(keyword: string) {
return this.get<string[]>({
url: `/api/search/albumInfo/completeSuggest/${keyword}`,
loading:false
})
}

}

export const search = new CateGory()

4.3 接口类型定义:


// 搜索参数
export interface SearchParamsInterface {
keyword: string;
category1Id?: number | null;
category2Id?: number | null;
category3Id?: number | null;
attributeList?: string[] | null;
order?: string | null;
pageNo?: number;
pageSize?: number;
}
// 搜索结果item向接口
export interface SearchItemInterface {
id: number;
albumTitle: string;
albumIntro: string;
announcerName: string;
coverUrl: string;
includeTrackCount: number;
isFinished: string;
payType: string
createTime: string;
playStatNum: number;
collectStatNum: number;
buyStatNum: number;
albumCommentStatNum: number;
}

4.4 接口引用


所有export的类接口方法都在api/index.ts中统一引入:


export { courseService } from './category/category'
export { albumsService } from './albums/albums'
export { search } from './search/search'

在页面中使用:


<script>
import { courseService } from "../../api"
/**
* @description: 获取所有分类
* @returns {*}
*/

const getCategoryList = async () => {
try {
const res = await courseService.findAllCategory()
} catch (error) {
console.log(error)
}
}
</script>

6.分支命名规范


分支管理命名规范解释
master 主分支master稳定版本分支,上线完成回归后后,由项目技术负责人从 release 分支合并进来,并打 tag
test 测试分支test/版本号示例:test/1.0.0测试人员使用分支,测试时从 feature 分支合并进来,支持多人合并
feature 功能开发分支feature/功能名称示例:feature/blog新功能开发使用分支,基于master建立
bugfix修复分支bugfix/功能名称示例:fix/blog紧急线上bug修复使用分支,基于master建立
release 上线分支release/版本号示例:release/0.1.0用于上线的分支,基于 master 建立,必须对要并入的 分支代码进行 Code review 后,才可并入上线

7.代码提交规范


作者:白哥学前端
来源:juejin.cn/post/7224408845685522492
tbody>
前缀解释示例
feat新功能feat: 添加新功能
fix修复fix: 修改bug
docs文档变更docs: 更新文档
style代码样式变更style: 修改样式
refactor重构refactor: 重构代码
perf性能优化perf: 优化了性能
test增加测试test: 单元测试
revert回退revert: 回退代码
build打包build: 打包代码
chore构建过程或辅助工具的变动chore: 修改构建
收起阅读 »

html手写一个打印机效果-从最基础到学会

web
手写一个打印机效果 啥叫打印机效果,话不多说,直接上效果。我们可以自己写入一段文本然后通过html的方式,让它跟打印机一样,一个一个的打印到页面,并且还可以一个一个的删除。在这里我先浅说一下,我们的实现技巧,定时器setTimeout控制时间,然后for循环遍...
继续阅读 »

手写一个打印机效果


啥叫打印机效果,话不多说,直接上效果。我们可以自己写入一段文本然后通过html的方式,让它跟打印机一样,一个一个的打印到页面,并且还可以一个一个的删除。在这里我先浅说一下,我们的实现技巧,定时器setTimeout控制时间,然后for循环遍历写入到页面上。


封装的打印js
main(str,text)直接传入要写入的数组对象和要写入的元素。
copy.js 下载到本地引入然后调用它就可以了
image.png


代码


先拿到我们要写入的元素,然后设置好我们要写入的内容。


 var text = document.querySelector('.text');
var str = ['你好 ,我是一名刚入坑不久的大三在校生。', '现在学习都是为了将来的工作。', '希望能够得到大家的鼓励,谢谢!']

基础代码一


首先这里,我们先实现一个只有一段文字的实现效果。实现思路就是通过计时器,控制好时间,每次写入的文字通过str[0].substr(0, k)拿到,需要注意的是,因为是异步任务,回退的时候,我们的时间要设置好,加上写入完的时间1000 + 200 * str[0].length)


  写入
for (let j = 0; j < str[0].length; j++) {
// 使用 setTimeout 函数来实现每个字符的延时输出
setTimeout(() => {
text.innerHTML = str[0].substr(0, j) // 显示当前字符串的前 j 个字符
}, 200 * j) // 延迟时间为 200 毫秒乘以 j,即每个字符间隔 200 毫秒
}

// 回退
// 在所有字符输出完成后,等待 1000 毫秒后开始回退
setTimeout(() => {
for (let k = str[0].length, i = 0; k >= 0; k--, i++) {
// 使用 setTimeout 函数来实现每个字符的延时输出
setTimeout(() => {
text.innerHTML = str[0].substr(0, k) // 显示当前字符串的前 k 个字符
}, 200 * i) // 延迟时间为 200 毫秒乘以 i,即每个字符间隔 200 毫秒
}
}, 1000 + 200 * str[0].length) // 等待时间为 1000 毫秒加上所有字符输出的延时时间

基础代码二 错误代码


首先这个代码是错误的
为了能让大家更好的看到错误的效果,于是我把这个代码也上传了。大家可以看到,在这里,页面上的文字总是会莫名奇怪的出现删除,根本不是我们想要的。其实我们也只是对上面一个代码进行了一个for循环遍历,却出现了这样的效果。其实这导致的原因就是setTimeout是异步任务,时间没有控制好。即每个字符串的打印和删除都是异步任务,无法保证它们的执行顺序。因此,可能会出现多个字符串的打印和删除任务交错执行的情况,导致效果不符合预期。



 // 即每个字符串的打印和删除都是异步任务,无法保证它们的执行顺序。因此,可能会出现多个字符串的打印和删除任务交错执行的情况,导致效果不符合预期。
// 整个str 这是一个有问题的代码 因为计算时间太麻烦了 都是异步任务
// for (let s = 0; s < str.length; s++) {
// // 写入
// for (let j = 0; j < str[s].length; j++) {
// setTimeout(() => {
// text.innerHTML = str[s].substr(0, j)
// }, 200 * j)
// }
// // 回退
// setTimeout(() => {
// for (let k = str[s].length, i = 0; k >= 0; k--, i++) {
// setTimeout(() => {
// text.innerHTML = str[s].substr(0, k)
// }, 200 * i)

// }
// }, 1000 + 200 * str[s].length)
// }

基础代码三


为了解决上面的问题,我们使用了函数封装并且使用了回调函数实现我们想要的效果。我们将打印和删除都封装成一个含有回调函数的函数,为什么要含有回调函数呢?这是为了我们下面对一个字符串打印和删除的函数做封装。打我们打印完一个字符串时,我们才会执行删除。所有我们将删除函数放到打印的回调函数中去执行。然后我们将打印整个字符串数组进行封装,因为我们在删除的里面也有一个回调函数,那么我们可以在这个回调函数里去执行打印下一条字符串,这样就防止了控制时间不准确的问题。


 // 打印字符串
function printText(str, callback) {
var i = 0;
var timer = setInterval(function () {
text.innerHTML = str.substr(0, i); // 将字符串的前缀赋值给显示文本的元素
i++;
if (i > str.length) { // 如果已经打印完整个字符串
clearInterval(timer); // 停止定时器
callback && callback(); // 调用回调函数
}
}, 200); // 每 200 毫秒打印一个字符
}

// 删除字符串
function deleteText(str, callback) {
var i = str.length;
var timer = setInterval(function () {
text.innerHTML = str.substr(0, i); // 将字符串的前缀赋值给显示文本的元素
i--;
if (i < 0) { // 如果已经删除到空字符串
clearInterval(timer); // 停止定时器
callback && callback(); // 调用回调函数
}
}, 200); // 每 200 毫秒删除一个字符
}

// 打印和删除字符串
function printAndDeleteText(str, callback) {
printText(str, function () { // 先打印字符串
setTimeout(function () {
deleteText(str, callback); // 等待 1 秒后再删除字符串
}, 1000);
});
}

// 循环遍历字符串数组,依次打印和删除字符串
function printAndDeleteAllText(strArr) {
function printAndDeleteNext(i) {
if (i >= strArr.length) { // 如果已经处理完所有字符串
printAndDeleteNext(0); // 重新从头开始处理
} else {
printAndDeleteText(strArr[i], function () { // 先打印字符串
i++;
printAndDeleteNext(i); // 递归调用自身,处理下一个字符串
});
}
}
printAndDeleteNext(0); // 开始处理第一个字符串
}
// 开始打印和删除字符串数组中的所有字符串
printAndDeleteAllText(str)

最优代码


其实我们做了,这么多,最后就是为了解决异步任务。
所以我这里直接采用Promiseasync await解决上面的问题。我们通过Promise解决实现打印和删除的异步任务。我们通过async await封装整个运行函数,解决了定时器异步问题,不用再计算时间,又难有算不出来。


 // 最终版 封装 解决异步任务
function writeText(t, delay = 200) {
return new Promise((resolve, reject) => {
setTimeout(() => {
text.innerHTML = t; // 显示当前字符串 t
resolve(); // Promise 完成
}, delay) // 延迟 delay 毫秒后执行
})
}

async function main(str) {
while (true) { // 无限循环
for (let j = 0; j < str.length; j++) {
// 写入
for (let i = 0; i <= str[j].length; i++) {
await writeText(str[j].substr(0, i)) // 显示当前字符串的前 i 个字符
}
// 回退
// 回退前先等一秒
await new Promise((resolve, reject) => {
setTimeout(() => {
resolve(); // 等待 1000 毫秒后 Promise 完成
}, 1000) // 等待 1000 毫秒
})
for (let i = str[j].length; i >= 0; i--) {
await writeText(str[j].substr(0, i), 200) // 显示当前字符串的前 i 个字符,间隔 200 毫秒
}
}
}
}
main(str)

源码


<!DOCTYPE html>
<html lang="en">

<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>打印机效果</title>
<style>
.container {
display: flex;
/* 使用 flex 布局 */
flex-direction: column;
/* 垂直布局 */
align-items: center;
/* 水平居中 */
justify-content: center;
/* 垂直居中 */
height: 100vh;
/* 高度占满整个视口 */
}

h1 {
font-size: 3rem;
/* 字体大小 */
margin-bottom: 2rem;
/* 底部间距 */
text-align: center;
/* 居中对齐 */
}

.text {
font-size: 2rem;
/* 字体大小 */
font-weight: bold;
/* 字体加粗 */
text-align: center;
/* 居中对齐 */
border-right: 2px solid black;
/* 添加光标效果 */
white-space: nowrap;
/* 不换行 */
overflow: hidden;
/* 隐藏超出部分 */
animation: blink 0.5s step-end infinite;
/* 添加光标闪烁效果 */
height: 3rem;
/* 设置一个固定的高度 */
}


@keyframes blink {

from,
to {
border-color: transparent;
/* 透明边框颜色 */
}

50% {
border-color: black;
/* 黑色边框颜色 */
}
}
</style>
</head>

<body>
<div class="container">
<h1>逐字打印和删除文字效果</h1>
<p class="text"></p>
</div>
</body>
<script>
var text = document.querySelector('.text');
var str = ['你好 ,我是一名刚入坑不久的大三在校生。', '现在学习都是为了将来的工作。', '希望能够得到大家的鼓励,谢谢!']


// 写入
// for (let j = 0; j < str[0].length; j++) {
// // 使用 setTimeout 函数来实现每个字符的延时输出
// setTimeout(() => {
// text.innerHTML = str[0].substr(0, j) // 显示当前字符串的前 j 个字符
// }, 200 * j) // 延迟时间为 200 毫秒乘以 j,即每个字符间隔 200 毫秒
// }

// // 回退
// // 在所有字符输出完成后,等待 1000 毫秒后开始回退
// setTimeout(() => {
// for (let k = str[0].length, i = 0; k >= 0; k--, i++) {
// // 使用 setTimeout 函数来实现每个字符的延时输出
// setTimeout(() => {
// text.innerHTML = str[0].substr(0, k) // 显示当前字符串的前 k 个字符
// }, 200 * i) // 延迟时间为 200 毫秒乘以 i,即每个字符间隔 200 毫秒
// }
// }, 1000 + 200 * str[0].length) // 等待时间为 1000 毫秒加上所有字符输出的延时时间


// 即每个字符串的打印和删除都是异步任务,无法保证它们的执行顺序。因此,可能会出现多个字符串的打印和删除任务交错执行的情况,导致效果不符合预期。
// 整个str 这是一个有问题的代码 因为计算时间太麻烦了 都是异步任务
// for (let s = 0; s < str.length; s++) {
// // 写入
// for (let j = 0; j < str[s].length; j++) {
// setTimeout(() => {
// text.innerHTML = str[s].substr(0, j)
// }, 200 * j)
// }
// // 回退
// setTimeout(() => {
// for (let k = str[s].length, i = 0; k >= 0; k--, i++) {
// setTimeout(() => {
// text.innerHTML = str[s].substr(0, k)
// }, 200 * i)

// }
// }, 1000 + 200 * str[s].length)
// }


// 最终版 封装 解决异步任务
function writeText(t, delay = 200) {
return new Promise((resolve, reject) => {
setTimeout(() => {
text.innerHTML = t; // 显示当前字符串 t
resolve(); // Promise 完成
}, delay) // 延迟 delay 毫秒后执行
})
}

async function main(str) {
while (true) { // 无限循环
for (let j = 0; j < str.length; j++) {
// 写入
for (let i = 0; i <= str[j].length; i++) {
await writeText(str[j].substr(0, i)) // 显示当前字符串的前 i 个字符
}
// 回退
// 回退前先等一秒
await new Promise((resolve, reject) => {
setTimeout(() => {
resolve(); // 等待 1000 毫秒后 Promise 完成
}, 1000) // 等待 1000 毫秒
})
for (let i = str[j].length; i >= 0; i--) {
await writeText(str[j].substr(0, i), 200) // 显示当前字符串的前 i 个字符,间隔 200 毫秒
}
}
}
}
main(str)
</script>

</html>

作者:Mr-Wang-Y-P
来源:juejin.cn/post/7225178555827191868
收起阅读 »

URL刺客现身,竟另有妙用!

web
工作中大家会接触到形形色色的 url,有些完美遵循格式,有些却像刺客一样,冷不丁的给你一刀。 先介绍下我的惨痛经历,给大家避避坑,最后告诉大家一个 url 刺客的妙用。 刺客介绍 1. iOS WKWebview 刺客 此类刺客手段单一,只会影响 iOS WK...
继续阅读 »

工作中大家会接触到形形色色的 url,有些完美遵循格式,有些却像刺客一样,冷不丁的给你一刀。


先介绍下我的惨痛经历,给大家避避坑,最后告诉大家一个 url 刺客的妙用。


刺客介绍


1. iOS WKWebview 刺客


此类刺客手段单一,只会影响 iOS WKWebview



  • 空格


运营人员由于在通讯工具中复制粘贴,导致前面多了一个空格,没有仔细检查,直接录入了后台管理系统。



  • 中文


运营人员为了方便自身统计,直接在url中加入中文,录入了后台管理系统。


现象均为打开一个空白页,常见的处理手段如下:



  • 将参数里的中文URIEncode

  • 去掉首尾空格


const safeUrl = (url: string) => {
const index = url.indexOf('?');

if (index === -1) return url.trim();

// 这行可以用任意解析参数方法替代,仅代表要拿到参数,不考虑兼容性的简单写法
const params = new URLSearchParams(url.substring(index));
const paramStr = Object.keys(params)
.map((key: string) => {
return `${key}=${encodeURIComponent(params[key])}`;
})
.join('&');

const formatUrl = url.substring(0, index + 1) + paramStr;

return formatUrl.trim();
};

可以看到虽然这里提出了一个 safeUrl 方法,但如果业务中大量使用 window.location.href , window.location.replace, 之类的方法进行跳转,替换起来会比较繁琐.


再比如在 Hybrid App 的场景中,虽然都是跳转,打开新的 webview ,还是在本页面跳转会是不同的实现,所以在业务内提取一个公共的跳转方法更有利于健壮性和拓展性。


值得注意的是,如果链接上的中文可能是用于统计的,在上报打点时,应该将其值(前端/服务端处理均可)进行 URIDecode,否则运营人员会在后台看到一串串莫名其妙的 %XX ,会非常崩溃(别问我怎么知道的,可能只是伤害过太多运营)


2. 格式刺客


格式刺客指的是,不管何种原因,不知何种场景,就是不小心配错了,打错了,漏打了等。


比如:https://www.baidu.com 就被打成了 htps://www.baidu.com、www.baidu.com 等。


// 检查URL格式是否正确
function isValidUrl(url: string): boolean {
const urlPattern = new RegExp(
"^(https?:\/\/)?" + // 协议
"(([a-zA-Z0-9-]+\.)+[a-zA-Z]{2,})" + // 域名
"(:[0-9]{1,5})?" + // 端口号
"(\/.*)?$", // 路径
"i"
);
return urlPattern.test(url);
}

以上是一个很基础的判断,但是实际的应用场景中,有可能会需要填写相对路径,或者自定义的 scheme ,比如 wx:// ,所以检验的宽松度可以自行把握。


在校验到 url 配置可能存在问题时,可以上报到 sentry 或者其他异常监控平台,这样就可以比用户上报客服更早的发现潜在问题,避免长时间的运营事故。


3. 异形刺客


这种刺客在视觉上让人无法察觉,只有在跳转后才会让人疑惑不已。他也是最近被产品同学发现的,以下是当时的现场截图:



一段平平无奇的文本,跟着一段链接,视觉上无任何异常。


经过对跳转后的地址进行分析,发现了前面居然有一个这样的字符%E2%80%8B,好奇的在控制台中进行了尝试。




一个好家伙,这是什么,两个单引号吗?并不是,对比了很常用的 '%2B' ,单引号是自带的,那么我到底看到了什么,魔鬼嘛~


在进行了一番检索后知道了这种字符被称为零宽空格,他还有以下兄弟:



  • \u202b-\u202f

  • \ufeff

  • \u202a-\u202e


具体含义可以看看参考资料,这一类字符完全看不见,但是却对程序的运行产生了恶劣的影响。


可以使用这个语句去掉


str.replace(/[\u200b-\u200f\uFEFF\u202a-\u202e]/g, "");

刺客的妙用


头一天还被刺客气的瑟瑟发抖。第二天居然发现刺客的妙用。


场景:




  • 产品要求在微信环境隐藏标题




我方前端工程师:



  • 大手一挥,发功完毕,准备收工


document.title = '';

测试:




  • 来看看,页面A标题隐藏不了




我方前端工程师:


啊?怎么回事,本地调试还是好的,发上去就不行了,为什么页面A不可以,另外一个页面B只是参数变了变就行。


架构师出手:


页面A包含了开放标签,导致设置空Title失效,空,猛然想起了刺客,快用起来!


function setTitle(title: string) {
if (title) {
document.title = title;
} else {
document.title = decodeURIComponent('%E2%80%8B');
}
}

果然有效,成功解决了一个疑难杂症,猜测是微信里有不允许设置标题为空的机制,会在某些标签存在的时候被触发。(以上场景在 Android 微信 Webview 中可复现)


小结


以上只是工作中碰到 url 异常的部分场景和处理方案,如果小伙伴们也有类似的经历,可以在评论区中分享,帮助大家避坑,感谢朋友们的阅读,笔芯~


参考资料:


零宽字符 - 掘金LvLin


什么零宽度字符,以及零宽度字符在JavaScript中的应用 - 掘金whosmeya


作者:windyrain
来源:juejin.cn/post/7225133152490094651
收起阅读 »

关于 Emoji 你不知道的事

web
2022 年,支付宝上线了生僻字键盘,解决了“身份认证”环节中普通输入法经常打不出生僻字的问题。生僻字键盘是蚂蚁集团生僻字解决方案的一部分,本系列将持续分享其背后的字符编码科普文章,包括不限于:《文字是如何显示在屏幕上的?》、《字符编码工作者都在做什么》,敬请...
继续阅读 »

2022 年,支付宝上线了生僻字键盘,解决了“身份认证”环节中普通输入法经常打不出生僻字的问题。生僻字键盘是蚂蚁集团生僻字解决方案的一部分,本系列将持续分享其背后的字符编码科普文章,包括不限于:《文字是如何显示在屏幕上的?》、《字符编码工作者都在做什么》,敬请期待。


本文作者是蚂蚁集团前端工程师醉杭(👉 点击查看醉杭的成长故事),本篇将介绍 Emoji 的编码逻辑,以及如何在代码中正确处理 Emoji 。蚂蚁集团前端工程师七柚封装了字符处理 js 库,已开源,欢迎使用~ github.com/alipay/char…



结论先行



  • 基本 emoji 和常用 Unicode 字符毫无区别


每个 emoji 用对应一个 Unicode 码位,如:🌔 U+1F314 (对应 JS 中 UTF-16 编码是:"\uD83C\uDF14"),汉字 𠇔 U+201D4,对应 JS 中的 UTF-16 编码是"\uD840\uDDD4"



  • emoji 有特殊的修饰、拼接等规则


在某些 emoji 字符后增加一个肤色修饰符改变 emoji 的肤色、可以将多个 emoji 通过连接符拼接成一个emoji,这些特殊规则使得在代码中判定 emoji 的长度、截取和对 emoji 做其他处理都比较困难。需要澄清的是:用一个 Unicode 字符修饰前一个字符不是 emoji 独有的,其他 Unicode 字符也存在,如:Ü,由大写字母U(U+0055),后面跟一个连音符号(U+0308)组成。



  • 术语


码点/码位:Unicode 编码空间中的一个编码,如,汉字𠇔的码位是 201D4,通常表示为:U+201D4


起源


1982 年,卡内基美隆大学是首次在电子公告里中使:-)表情符号。后续在日本手机短信中盛行,并称为颜文字(日语:かおもじ,英文:emoticon),颜文字仍然是普通的文本字符。
1999 年,栗田穰崇 (Shigetaka Kurita) 发明了 e-moji (え-もじ),并设计了 176 个 emoji 符号,共 6 种颜色,分辨率为 12x12。
image.png
纽约博物馆馆藏:最初的 176 个 emoji


2010 年,Unicode 正式收录了 emoji,为每个 emoji 分配了唯一的码点。
2011 年,Apple 在 iOS 中加入了标准的 emoji 输入键盘,2 年后安卓系统也引入了 emoji 键盘。


Unicode


Unicode 中原本就收录了很多有意义的字符,如:㎓、𐦖、☳,大家还可以查看 Unicode 1 号平面的埃及象形文字区 (U+13000–U+1342F)。收录 emoji 对 Unicode 来说没有挑战,技术上是完全兼容的。
image.png
Unicode 象形文字区节选


Emoji 的编码


基本 emoji



基本 emoji 是指在 Unicode 编码表中用 1 个唯一码位表示的 emoji



最简单的 emoji 就是 Unicode 表中的一个字符,和我们常用的 Unicode 字符没有区别。多数基本 emoji 都被分配到 Unicode 编码表 1 号平面的 U+1F300–1F6FFU+1F900–1FAFF 两个区域,完整的列表请看15.0/emoji-sequences.txt
image.png
Unicode 中 emoji 的码位


我们常见的 emoji 是彩色的,而常见的字体是黑色的。字符的颜色取决于字体文件,如果你愿意,你也可以把其常见的汉字字体设计成彩色的。iOS/MacOS 的Apple Color Emoji字体是一种 160x160 的点阵字体, Android 的Noto Emoji是一种 128x128 的点阵字体,而 Windows 使用的 Segoe UI Emoji 是一种矢量彩色字体。


为什么同一个 emoji 在不同设备、不同软件中显示不同?
不同设备、软件使用了不同的 emoji 字体所以显示效果不同。Unicode 只是约定了码点到 emoji 的映射关系,并没有约定 emoji 图形,每个 emoji 字体文件可以按照自己的想法设计 emoji。
image.png
同一个 emoji 在不同软件上的显示效果


为什么在钉钉中发送**[憨笑]**会显示成image.png
早期包含 Unicode emoji 的字体还没广泛普及,你给对方发一个 emoji 符号😄,如果没对方设备有对应的字体看到的会是**?**
为了解决缺失 emoji 字体导致大家显示不一致的问题(或者为了方便自定义自己的**伪emoji**——为了方便描述,把软件自定义的图片称作伪 emoji),很多软件自己开发了能向下兼容的解决方案,如钉钉。该自定义方案与 Unicode 编码没有关系,只是将特殊的字符串与一张图片映射起来,当对方发送[xx]字符串时,将它显示成对应的图片
早期支付宝的转账备注功能中也定义了自己的伪emoji伪emoji的好处是向下兼容,如果使用标准的Unicode emoji 可能会导致别的系统无法处理(如:做了汉字正则校验),导致转账失败;弊端是不通用,别的系统通常不支持另一个系统定义的伪emoji,直接将[xx]文本显示出来,如:收银台在支付界面就会直接显示转账备注的伪 emoji 文本[xx]
image.png


字素集


字素集(grapheme cluster)在 Unicode 中通常一个码点对应一个字符,但是 Unicode 引入了特定的机制允许多个 Unicode 码点组合成一个字形符号。这样由于多个码点组合成的一个字符称作字素集。
比如Ü是一个字素集,是由两个码点组成:大写字母 U(U+0055),后面跟一个连音符号(U+0308)。再比如:'曙󠄀'.length=3'🤦🏼‍♂️'.length=7,前者由基本的字符加上一个变体选择符️ VS-17 (见后文)组成,后者由多个基础 emoji 修饰符、连接符组成。
点开有惊喜Ų̷̡̡̨̫͍̟̯̣͎͓̘̱̖̱̣͈͍̫͖̮̫̹̟̣͉̦̬̬͈͈͔͙͕̩̬̐̏̌̉́̾͑̒͌͊͗́̾̈̈́̆̅̉͌̋̇͆̚̚̚͠ͅ[左边是一个.length 为 65 的字素集,它是不可分割的一个字符]


在 Unicode 的规范中要求所有软件(本编辑器、文本渲染、搜索等)将一个字素集当做不可分割的整体,即:当做一个单一的字符对待。
image.png
Unicode 处理的难点就在于字素集,下文均与该定义有关,开发者的噩梦都源自该概念。不能简单地通过 .length 读取字符串的长度;如果想截取字符串的前 10 个字符,也不能简单的使用.substring(0, 10),因为这可能会截断 emoji 字符;反转字符串也非常困难,U+263A U+FE0F 有意义,反转之后 U+FE0F U+263A 却没有意义,后文会介绍正确的处理方式。


变体选择符️


Variation Selector(又叫异体字选择器),是 Unicode 中定义的一种修饰符机制。一个基本字符后接上一个异体字选择器组成一个异体字。背景是:一个字符可能会有多个不同的变体,这些变体本质上是同一个字符,具有同样的含义,由于地区、文化差异导致他们演变成了不同的书写形式。Unicode 为变体字分配了同一个码点,如果想要显示特定的书写形式可以在字符后紧接着一个异体字选择器指定。
image.pngimage.png就是变体字。需要澄清的是,并非所有相似的字符都按照异性字的形式合并成了一个码点,就是分别分配了不同的码点,理论上这两个字符也可以合并变体字共用一个码点。
在 Unicode 中引入彩色的 emoji 前就已经定义了一些黑色的图形符号,引入彩色 emoji 后,新的 emoji 与黑色的符号具有相同的含义,于是共用了同一个 Unicode 码点,可在字符后接上一个 VS 指定要显示那个版本。
常用的 VS 有 16 个 VS-1 ~ VS-16,对应的 Unicode 是(U+FE00~U+FE0F),其中 VS-15(U+FE0E)用于指定显示黑色的 text 版本,VS-16(U+FE0F)用于指定显示彩色的 emoji 版本。


默认显示VS-15 修饰符VS-16 修饰符
U+2702✂︎U+2702 U+FE0E✂︎U+2702 U+FE0F ✂️
U+2620☠︎U+2620 U+FE0E☠︎U+2620 U+FE0F ☠️
U+26A0⚛︎U+26A0 U+FE0E⚛︎U+26A0 U+FE0F ⚛️
U+2618☘︎U+2618 U+FE0E☘︎U+2618 U+FE0F ☘️

可以动手验证一下



image.png



  • ✂ 不含修饰符'\u2702'

  • ✂︎ 含 VS-15'\u2702\uFE0E'

  • ✂️ 含 VS-16'\u2702\uFE0F'



为什么把黑色的剪刀 ✂︎ 粘贴到 Chrome 搜索栏中显示成彩色,把彩色剪刀 ✂️ 复制到 Chrome 的 Console 中显示成黑色?
image.png image.png
我们通过 VS 符号告诉软件要显示成指定的异体字符,但是软件可以不听我们的,软件可能会强制指定特定的字体,如果该字体中只包含一种异体字符的字形数据那就只会显示该字形。


肤色修饰符


大多数人形相关的 Emoji 默认是黄色的,在 2015 年为 emoji 引入肤色支持。没有为每种肤色的 emoji 组合分配新的码点,而是引入了五个新码点作为修饰符:1F3FB 🏻、1F3FC 🏼、1F3FD 🏽、1F3FE 🏾、1F3FF 🏿 。肤色修饰符追加到现有的 emoji 后面则形成新的变种,如:👋 U+1F44B+ 🏽U+1F3FD= 👋🏽



  • 👋 在 JavaScript 中 UTF-16 值是'\uD83D\uDC4B'

  • **🏽 **在 JavaScript 中 UTF-16 值是'\uD83C\uDFFD'


组合在一起'\uD83D\uDC4B\uD83C\uDFFD'就得到了 👋🏽
image.png


5 种肤色修饰符的取值是基于菲茨帕特里克度量,因此叫做 EMOJI MODIFIER FITZPATRICK。肤色度量共有 6 个取值,但在 emoji 中前两个颜色合并成了一个。
image.png
最终 280 个人形 emoji 就产生了 1680 种肤色变种,这是五种不同肤色的舞者:🕺🕺🏻🕺🏼🕺🏽🕺🏾🕺🏿


零宽度连接符(ZWJ)


Unicode 通过多个基础 emoji 组合的形式表示某些复杂 emoji。组合的方式是在两个 emoji 之间添加一个U+200D,即:零宽度连接符(ZERO-WIDTH JOINER,简写为 ZWJ),如:



  • 👩 + ZWJ+ 🌾 = 👩‍🌾


image.png
下面是一些例子,完整的组合列表参考:Unicode 15.0/emoji-zwj-sequences.txt




  • 👩 + ✈️ → 👩‍✈️

  • 👨 + 💻 → 👨‍💻

  • 👰 + ♂️ → 👰‍♂️

  • 🐻 + ❄️ → 🐻‍❄️

  • 🏴 + ☠️ → 🏴‍☠️

  • 🏳️ + 🌈 → 🏳️‍🌈

  • 👨 + 🦰 → 👨‍🦰 (有意思的是:发色是通过 ZWJ 组合基础 emoji 实现,而肤色则是用肤色修饰符实现)

  • 👨🏻 + 🤝 + 👨🏼 → 👨🏻‍🤝‍👨🏼

  • 👨 + ❤️ + 👨 → 👨‍❤️‍👨

  • 👨 + ❤️ + 💋 + 👨 → 👨‍❤️‍💋‍👨

  • 👨 + 👨 + 👧 → 👨‍👨‍👧

  • 👨 + 👨 + 👧 + 👧 → 👨‍👨‍👧‍👧



可惜,有些 emoji 不是通过 ZWJ 组全 emoji 实现的,可能是因为没有赶上 ZWJ 定义的时机




  • 🌂 + 🌧 ≠ ☔️

  • 💄 + 👄 ≠ 💋

  • 🐴 + 🌈 ≠ 🦄

  • 👁 + 👁 ≠ 👀

  • 👨 + 💀 ≠ 🧟

  • 👩 + 🔍 ≠ 🕵️‍♀️

  • 🦵 + 🦵 + 💪 + 💪 + 👂 + 👂 + 👃 + 👅 + 👀 + 🧠 ≠ 🧍



旗帜·双字母连字


Unicode 中包含国旗符号,每个国旗也没有分配独立的码点,而是由双字符连字(ligature)来表示。(但 Windows 平台因为某些原因不支持显示,如果你是用 Windows 平台的浏览器阅读本文,只能说抱歉了)



  • 🇺 + 🇳 = 🇺🇳

  • 🇷 + 🇺 = 🇷🇺

  • 🇮 + 🇸 = 🇮🇸

  • 🇿 + 🇦 = 🇿🇦

  • 🇯 + 🇵 = 🇯🇵


这里的🇦 ~ 🇿不是字母,而是地区标识符,对应的码点是U+1F1E6~U+1F1FF,可以随意复制并组合,如果是合法的组合会显示成一个国家的旗帜。你可以在 MacOS 的 FontBook 中打开 Apple Color Emoji 查看到这些码点以及各个地区的旗帜符号
image.png image.png
完整地区标识符如下,你可以动手组合试一试:
🇦 🇧 🇨 🇩 🇪 🇫 🇬 🇭 🇮 🇯 🇰 🇱 🇲 🇳 🇴 🇵 🇶 🇷 🇸 🇹 🇺 🇻 🇼 🇽 🇾 🇿


标签序列


在 Unicode 中称作 Emoji Tag Sequence。在 Unicode 中U+E0020~ U+E007F 95 个码点表示的是Unicode 中不可见的控制符号,其中从E0061~E007A的 26 个码点分别表示小写的拉丁字符(不是常规的拉丁字母,而是 emoji 相关的控制字符),对应关系如下:




  • U+E0061 - TAG LATIN SMALL LETTER A

  • U+E0062 - TAG LATIN SMALL LETTER B



...




  • U+E007A - TAG LATIN SMALL LETTER Z



前文的双字母连字机制支持将两个地区标识符连接在一起表示一个旗帜符号。标签序列与之类似,是 Unicode 中定义的一种更复杂的连接方式,格式是:基础emoji+ 一串拉丁标签字符(U+E0061~U+E007A) + 结束符(U+E007F)
如:🏴 + gbeng + U+E007F = 🏴󠁧󠁢󠁥󠁮󠁧󠁿
其中 🏴 是基础 emoji U+1F3F4,_gbeng _分别代表对应的拉丁控制字符: g(U+E0067)b(U+E0062)e(U+E0065) n(U+E006E)g(U+E0067)U+E007F表示结束符,全称是 TAG CANCEL


/**
* 根据地区缩写返回对应的emoji
* 如:flag('gbeng') -> 🏴󠁧󠁢󠁥󠁮󠁧󠁿
*/

function flag(letterStr) {
const BASE_FLAG = '🏴';
const TAG_CANCEL = String.fromCodePoint(0xE007F);

// 将普通字母字符序列转换为"标签拉丁字符"序列
const tagLatinStr = (letterStr.toLowerCase().split('').map(letter => {
const codePoint = letter.charCodeAt(0) - 'a'.charCodeAt(0) + 0xE0061;
return String.fromCodePoint(codePoint);
})).join('');


return BASE_FLAG + tagLatinStr + TAG_CANCEL;
}

目前用这种方式表示的 emoji 共有三个



  • 🏴 + gbeng + U+E007F = 🏴󠁧󠁢󠁥󠁮󠁧󠁿 英格兰旗帜,完整序列:1F3F4 E0067 E0062 E0065 E006E E0067 E007F

  • 🏴 + gbsct + U+E007F = 🏴󠁧󠁢󠁳󠁣󠁴󠁿 苏格兰旗帜,完整序列:1F3F4 E0067 E0062 E0073 E0063 E0074 E007F

  • 🏴 + gbwls + U+E007F = 🏴󠁧󠁢󠁷󠁬󠁳󠁿 威尔士旗帜,完整序列:1F3F4 E0067 E0062 E0077 E006C E0073 E007F


键位符


共有 12 个键位符 #️⃣ *️⃣ 0️⃣ 1️⃣ 2️⃣ 3️⃣ 4️⃣ 5️⃣ 6️⃣ 7️⃣ 8️⃣ 9️⃣,规则是这样的:井号、星号和数字,加 U+FE0F 变成 emoji,再加上U+20E3变成带方框的键位符。







      • FE0F + 20E3 = *️⃣






  • + FE0F + 20E3 = #️⃣



  • 0 + FE0F + 20E3 = 0️⃣

  • ...


U+FE0F是前文提到的变体选择符中的VS-16,表示显示为 emoji 形态。JavaScript 中'\u0030'表示数字'0', '\u0030\ufe0f'则表示它的 emoji 变体,两者在 zsh 的 console 中显示效果不同,.length的值也不同。
image.png image.png


小结


一共有七种 emoji 造字法



  1. 基础emoji,单个码点表示一个emoji 🧛 U+1F9DB

  2. 单个码点 + 变体选择符 ⚛️ = ⚛︎ U+26A0 + U+FE0F

  3. 皮肤修饰符 🤵🏽 = 🤵 U+1F935 + 🏽 U+1F3FD

  4. **ZWJ连接符 ** 👨‍💻 = 👨 + ZWJ + 💻

  5. 旗帜符号 🇨🇳 = 🇨 + 🇳

  6. **标签序列 ** 🏴󠁧󠁢󠁳󠁣󠁴󠁿 = 🏴 + gbsct + U+E007F

  7. **键位序列 ** *️⃣ = * + U+FE0F + U+20E3


前四种方法也可以组合使用,可构造非常复杂的 emoji



U+1F6B5 🚵 个人山地骑行



  • U+1F3FB 浅色皮肤

  • U+200D ZWJ

  • U+2640 ♀️女性标志

  • U+FE0F 变体标志
    = 🚵🏻‍♀️ 浅色皮肤的女性山地骑行



/**
* 显示一个字符种所有的Unicode码点
*/

function codePoints(str) {
const result = [];
for(let i = 0; i < str.length; i ++) {
result.push(str.codePointAt(i).toString(16).toUpperCase());
}
return result;
}
codePoints('🚵🏻‍♀️') => ['1F6B5', 'DEB5', '1F3FB', 'DFFB', '200D', '2640', 'FE0F']

如何在代码中正确处理 emoji?


emoji 引入的问题


'中国人123'.length = 6'工作中👨‍💻'.length = 8
emoji 给编程带来的主要问题是视觉上看到的字符长度(后文称作视觉 length)与代码中获取的长度(后文称作技术 length)不相同,使得字符串截取等操作返回非预期内的结果,如:
'工作中👨‍💻'.substr(0,5) => '工作中👨''工作中👨‍💻'.substr(5)' => '‍💻'


本质上在 emoji 出现之前 Unicode 编码就遇到了该问题,只不过 emoji 的普及让该问题更普遍。有的 emoji 长度为 1,有的长度可以达到 15。问题的根源是 Unicode 中可以用多个码点表示一个 emoji,如果所有 emoji 都用一个 Unicode 码点表示就不存在该问题。
image.png


解法:视觉 length VS. 技术 length


解法显而易见,只要能将字符串中所有的字符元素按照视觉上看到的情况准确拆分,即:准确拆解字符串中的所有字素集
下述伪代码是要实现的效果,很多开源工具库就在做同样的事情,搜:Grapheme Cluster 即可。找到一个JavaScript版的grapheme-splitter,但是数据已经过时(勿用)。


const vs = new VisualString('工作中👨‍💻');
// vs.length => 4; // 视觉长度
// vs.physicalLength => 8; // 字符串长度
// vs[0] => 工
// vs[3] => 👨‍💻 // 按照所见即所得的方式拆分字符

// 字素集方法
// vs.substr(3,1) => 👨‍💻 // 截取字符

// 字素集属性
// vs[3].physicalLength => 5 // 物理长度
// vs[3].isEmoji => true // 是否是emoji

我们将产出工具库中将要提供这些能力



  1. 判断一个字符串中是否包含 emoji

  2. 将一个字符串准确拆分成若干个字素集

    • 每个字素集包含这些属性:isEmojiphysicalLength



  3. 按照字素集对字符串做截取操作

    • 基础截取: new VisualString('👨123👨‍💻').substr(1, 4) => '123👨‍💻'

    • 限定物理长度截取:new VisualString('👨123👨‍💻').substr(1, 4, 6) => '123',最后一个参数6代表最大物理长度,其中'123👨‍💻'.length = 8,如果限定最大物理长度6则只能截取到'123'备注:在产品体验上我们遵循“所见即所得”,但是在后端系统中传输和存储时候要遵循物理长度的限制,因此需要提供限定物理长度的截取能力。




版本兼容问题


如果 A 向 B 发送了一个组合 emoji「工作👨‍💻123」,B 的系统或软件中版本低(兼容的 Unicode 版本低)不支持该组合 emoji,看到的可能会是「工作👨💻123」。
用看到的是👨‍💻还是👨💻取决于用户的操作系统、软件和字体,我们提供的 JS 库无法感知到用户最终看到的是什么。我们提供的 JS 库会按照最新 Unicode 规范实现,无论用户看到的是什么都会把它当成一个字符(准确地说是字素集),即:
const vs = new VisualString('工作👨💻123'); vs.length => 6; vs[2] => '👨💻'
有办法可以一定程度上解决上述问题,但是我们觉得可能不解决才是正确的做法。


一个彩蛋


最后希望你使用 emoji 愉快 😄
发现 emoji 的维护者彻底贯彻「众生平等」,除了推出了不同肤色的 emoji 外,竟还设计了一个 Pregnant Man :)
image.png 🤰🫃🫄🏼
以上是分别是 woman、man、person,emoji 的新趋势是设计中性的 emoji




参考



作者:支付宝体验科技
来源:juejin.cn/post/7225074892357173308
收起阅读 »

一个神奇的小工具,让URL地址都变成了"ooooooooo"

web
发现一个很有创意的小工具网站,如封面图所示功能很简单,就是将一个URL地址转换为都是 ooooooooo 的样子,通过转换后的地址访问可以转换回到原始地址,简单流程如下图所示。转换的逻辑有点像短链平台一样,只不过这个是将你的URL地址变的很长长长长,但是看着都...
继续阅读 »

发现一个很有创意的小工具网站,如封面图所示功能很简单,就是将一个URL地址转换为都是 ooooooooo 的样子,通过转换后的地址访问可以转换回到原始地址,简单流程如下图所示。转换的逻辑有点像短链平台一样,只不过这个是将你的URL地址变的很长长长长,但是看着都是 ooooooooo,很好奇是如何实现的,所以查阅了源码,本文解读其核心实现逻辑,很有趣且巧妙的实现了这个功能。



前置知识点


在正式开始前,先了解一些需要学习的知识点。因为涉及到两个地址其实也就是字符串之间的转换,会用到一些编码和解码的能力。


将字符转为utf8数组,转换后的每个字符都有一个特定的唯一数值,比如 http 转换后的 utf8 格式数组即是 [104, 116, 116, 112]


    toUTF8Array(str) {
var utf8 = [];
for (var i = 0; i < str.length; i++) {
var charcode = str.charCodeAt(i);
if (charcode < 0x80) utf8.push(charcode);
else if (charcode < 0x800) {
utf8.push(0xc0 | (charcode >> 6),
0x80 | (charcode & 0x3f));
}
else if (charcode < 0xd800 || charcode >= 0xe000) {
utf8.push(0xe0 | (charcode >> 12),
0x80 | ((charcode >> 6) & 0x3f),
0x80 | (charcode & 0x3f));
}
else {
i++;
charcode = ((charcode & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff)
utf8.push(0xf0 | (charcode >> 18),
0x80 | ((charcode >> 12) & 0x3f),
0x80 | ((charcode >> 6) & 0x3f),
0x80 | (charcode & 0x3f));
}
}
console.log(utf8, 'utf8');
return utf8;
}

上面是编码,对应下面的则是解码,将utf8数组转换为字符串,比如 [99, 111, 109] 转换后的 utf8 格式数组即是 com


    Utf8ArrayToStr(array) {
var out, i, len, c;
var char2, char3;

out = "";
len = array.length;
i = 0;
while (i < len) {
c = array[i++];
switch (c >> 4) {
case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
// 0xxxxxxx
out += String.fromCharCode(c);
break;
case 12: case 13:
// 110x xxxx 10xx xxxx
char2 = array[i++];
out += String.fromCharCode(((c & 0x1F) << 6) | (char2 & 0x3F));
break;
case 14:
// 1110 xxxx 10xx xxxx 10xx xxxx
char2 = array[i++];
char3 = array[i++];
out += String.fromCharCode(((c & 0x0F) << 12) |
((char2 & 0x3F) << 6) |
((char3 & 0x3F) << 0));
break;
}
}

return out;
}

将 Number 对象以 4 进制的形式表示为字符串,toString 用的比较多,但是里面传入参数的场景比较少,这个参数 radix 是一个可选的参数,用于指定转换的进制数,范围为 2 ~ 36,如果未传入该参数,则默认使用 10 进制。


n.toString(4)

在字符串左侧填充指定字符,直到字符串达到指定长度。基本语法为 str.padStart(targetLength [, padString])



  • targetLength:必需,指定期望字符串的最小长度,如果当前字符串小于这个长度,则会在左侧使用 padString 进行填充,直到字符串达到指定长度。

  • padString:可选,指定用于填充字符串的字符,默认为 " "(空格)。


str.padStart(4, '0')

URL 编码/解码


下面正式开始URL编码的逻辑,核心的逻辑如下:



  • 转换为utf8数组

  • 转换为4进制并左侧补0到4位数

  • 分割转换为字符串数组

  • 映射到o的不同形式

  • 再次拼接为字符串,即转换完成后的URL


// 获取utf8数组
let unversioned = this.toUTF8Array(url)
// 转换为base 4字符串
// padstart非常重要!否则会丢失前导0
.map(n => n.toString(4).padStart(4, "0"))
// 转换为字符数组
.join("").split("")
// 映射到o的不同形式
.map(x => this.enc[parseInt(x)])
// 连接成单个字符串
.join("")

上面有两个关键点解释一下,首先映射到o的不同形式这个是什么意思呢?其实转换后的o并不是一种“o”,而是4种,只不过我们肉眼看到的效果很像,通过 encodeURI 转换后的字符可以看出来。


encodeURI('o-ο-о-ᴏ')
// o-%CE%BF-%D0%BE-%E1%B4%8F

这里其实也解释了为什么上面为什么是转换为4进制和左侧补0到四位数。因为上面代码定义的 this.enc 如下,因为总共只有四种“o”,4进制只会产生0,1,2,3,这样就可以将转换后的utf8字符一一对应上这几种特殊的“o”。


enc = ["o", "ο", "о", "ᴏ"] 

最后的效果举例转换 http 这个字符:



  • 转换为utf8数组:[ 104, 116, 116, 112 ]

  • 转换为4进制并左侧补0到4位数:['1220', '1310', '1310', '1300']

  • 分割转换为字符串数组:['1', '2', '2', '0', '1', '3', '1', '0', '1', '3', '1', '0', '1', '3', '0', '0']

  • 映射到o的不同形式:[ 'ο', 'о', 'о', 'o', 'ο', 'ᴏ', 'ο', 'o', 'ο', 'ᴏ', 'ο', 'o', 'ο', 'ᴏ', 'o', 'o' ]

  • 再次拼接为字符串,即转换完成后的URL:οооoοᴏοoοᴏοoοᴏoo


到此整个转换编码的过程就结束了,看完后是不是觉得设计的很不错,编码完后就是解码,解码就是将上面的过程倒序来一遍,恢复到最原始的URL地址。这里要注意一点的是每次解析4个字符且parseInt以4进制的方式进行解析。


// 获取url的base 4字符串表示
let b4str = ooo.split("").map(x => this.dec[x]).join("")

let utf8arr = []
// 每次解析4个字符
// 记住添加前导0的填充
for (let i = 0; i < b4str.length; i += 4)
utf8arr.push(parseInt(b4str.substring(i, i + 4), 4))
// 返回解码后的字符串
return this.Utf8ArrayToStr(utf8arr)

最后


到此就核心实现代码就分享结束了,看完是不是感觉并没有很复杂,基于此设计或许可以延伸出其他的字符效果,有兴趣的也可以试试看。将转码后的地址分享给你的朋友们一定会带来不一样的惊喜。


以下将官网源码运行在码上掘金,方便大家体验。



下面是我转换的一个AI小工具地址,点击看看效果吧~


ooooooooooooooooooooooo.ooo/ooooοооoοᴏο…


看完本文如果觉得有用,记得点个赞支持,收藏起来说不定哪天就用上啦~


专注前端开发,分享前端相关技术干货,公众号:南城大前端(ID: nanchengfe)


作者:南城FE
来源:juejin.cn/post/7225573912670191677
收起阅读 »

十分钟,带你了解 Vue3 的新写法

web
最近因为项目需要,不得不学习一下 Vue3。于是花了 4 个小时,把 Vue3 过了一遍。现在我来带你快速了解 Vue3 的写法。 本文的目的,是为了让已经有 Vue2 开发经验的 人 ,快速掌握 Vue3 的写法。 因此, 本篇假定你已经掌握 Vue 的核心...
继续阅读 »

最近因为项目需要,不得不学习一下 Vue3。于是花了 4 个小时,把 Vue3 过了一遍。现在我来带你快速了解 Vue3 的写法。


本文的目的,是为了让已经有 Vue2 开发经验的 ,快速掌握 Vue3 的写法。


因此, 本篇假定你已经掌握 Vue 的核心内容 ,只为你介绍编写 Vue3 代码,需要了解的内容。


一、Vue3 里 script 的三种写法


首先,Vue3 新增了一个叫做组合式 api 的东西,英文名叫 Composition API。因此 Vue3 的 script 现在支持三种写法,


1、最基本的 Vue2 写法


<template>
<div>{{ count }}</div>
<button @click="onClick">
增加 1
</button>
</template>

<script>
export default {
data() {
return {
count: 1,
};
},
methods: {
onClick() {
this.count += 1;
},
},
}
</script>

2、setup() 属性


<template>
<div>{{ count }}</div>
<button @click="onClick">
增加 1
</button>
</template>

<script>
import { ref } from 'vue';
export default {

// 注意这部分
setup() {
let count = ref(1);
const onClick = () => {
count.value += 1;
};
return {
count,
onClick,
};
},

}
</script>

3、<script setup>


<template>
<div>{{ count }}</div>
<button @click="onClick">
增加 1
</button>
</template>

<script setup>
import { ref } from 'vue';

const count = ref(1);
const onClick = () => {
count.value += 1;
};
</script>

正如你看到的那样,无论是代码行数,还是代码的精简度,<script setup> 的方式是最简单的形式。


如果你对 Vue 很熟悉,那么,我推荐你使用 <script setup> 的方式。


这种写法,让 Vue3 成了我最喜欢的前端框架。


如果你还是前端新人,那么,我推荐你先学习第一种写法。


因为第一种写法的学习负担更小,先学第一种方式,掌握最基本的 Vue 用法,然后再根据我这篇文章,快速掌握 Vue3 里最需要关心的内容。


第一种写法,跟过去 Vue2 的写法是一样的,所以我们不过多介绍。


第二种写法,所有的对象和方法都需要 return 才能使用,太啰嗦。除了旧项目,可以用这种方式体验 Vue3 的新特性以外,我个人不建议了解这种方式。反正我自己暂时不打算精进这部分。


所以,接下来,我们主要介绍的,也就是 <script setup> ,这种写法里需要了解的内容。


注意: <script setup> 本质上是第二种写法的语法糖,掌握了这种写法,其实第二种写法也基本上就会了。(又多了一个不学第二种写法的理由)。


二、如何使用 <script setup> 编写组件


学习 Vue3 并不代表你需要新学习一个技术,Vue3 的底层开发思想,跟 Vue2 是没有差别的。


V3 和 V2 的区别就像是,你用不同的语言或者方言说同一句话。


所以我们需要关心的,就是 Vue2 里的内容,怎么用 Vue3 的方式写出来。


1、data——唯一需要注意的地方


整个 data 这一部分的内容,你只需要记住下面这一点。


以前在 data 中创建的属性,现在全都用 ref() 声明。


template 中直接用,在 script 中记得加 .value


在开头,我就已经写了一个简单的例子,我们直接拿过来做对比。


1)写法对比


 // Vue2 的写法

<template>
<div>{{ count }}</div>
<button @click="onClick">
增加 1
</button>
</template>

<script>
export default {
data() {
return {
count: 1,
};
},
methods: {
onClick() {
this.count += 1;
},
},
}
</script>

 // Vue3 的写法

<template>
<div>{{ count }}</div>
<button @click="onClick">
增加 1
</button>
</template>

<script setup>
import { ref } from 'vue';

// 用这种方式声明
const count = ref(1);

const onClick = () => {
// 使用的时候记得 .value
count.value += 1;
};
</script>

2)注意事项——组合式 api 的心智负担


a、ref 和 reactive

Vue3 里,还提供了一个叫做 reactiveapi


但是我的建议是,你不需要关心它。绝大多数场景下,ref 都够用了。


b、什么时候用 ref() 包裹,什么时候不用。

要不要用ref,就看你的这个变量的值改变了以后,页面要不要跟着变。


当然,你可以完全不需要关心这一点,跟过去写 data 一样就行。


只不过这样做,你在使用的时候,需要一直 .value


c、不要解构使用

在使用时,不要像下面这样去写,会丢失响应性。


也就是会出现更新了值,但是页面没有更新的情况


// Vue3 的写法
<template>
<div>{{ count }}</div>
<button @click="onClick">
增加 1
</button>
</template>

<script setup>
import { ref } from 'vue';

const count = ref(1);
const onClick = () => {
// 不要这样写!!
const { value } = count;
value += 1;
};
</script>

注意: 学习 Vue3 就需要考虑像这样的内容,徒增了学习成本。实际上这些心智负担,在学习的过程中,是可以完全不需要考虑的。


这也是为什么我推荐新人先学习 Vue2 的写法。


2、methods


声明事件方法,我们只需要在 script 标签里,创建一个方法对象即可。


剩下的在 Vue2 里是怎么写的,Vue3 是同样的写法。


// Vue2 的写法
<template>
<div @click="onClick">
这是一个div
</div>
</template>

<script>
export default {
methods: {
onClick() {
console.log('clicked')
},
},
}
</script>

// Vue3 的写法
<template>
<div @click="onClick">
这是一个div
</div>
</template>

<script setup>

// 注意这部分
const onClick = () => {
console.log('clicked')
}

</script>

3、props


声明 props 我们可以用 defineProps(),具体写法,我们看代码。


1)写法对比


// Vue2 的写法
<template>
<div>{{ foo }}</div>
</template>

<script>
export default {
props: {
foo: String,
},
created() {
console.log(this.foo);
},
}
</script>

// Vue3 的写法
<template>
<div>{{ foo }}</div>
</template>

<script setup>

// 注意这里
const props = defineProps({
foo: String
})

// 在 script 标签里使用
console.log(props.foo)
</script>

2)注意事项——组合式 api 的心智负担


使用 props 时,同样注意不要使用解构的方式。


<script setup>
const props = defineProps({
foo: String
})

// 不要这样写
const { foo } = props;
console.log(foo)
</script>

4、emits 事件


props 相同,声明 emits 我们可以用 defineEmits(),具体写法,我们看代码。


// Vue2 的写法
<template>
<div @click="onClick">
这是一个div
</div>
</template>

<script>
export default {

emits: ['click'], // 注意这里
methods: {
onClick() {
this.$emit('click'); // 注意这里
},
},

}
</script>

// Vue3 的写法
<template>
<div @click="onClick">
这是一个div
</div>
</template>

<script setup>

// 注意这里
const emit = defineEmits(['click']);

const onClick = () => {
emit('click') // 注意这里
}

</script>

5、computed


直接上写法对比。


// Vue2 的写法
<template>
<div>
<span>{{ value }}</span>
<span>{{ reversedValue }}</span>
</div>
</template>

<script>
export default {
data() {
return {
value: 'this is a value',
};
},
computed: {
reversedValue() {
return value
.split('').reverse().join('');
},
},
}
</script>

// Vue3 的写法
<template>
<div>
<span>{{ value }}</span>
<span>{{ reversedValue }}</span>
</div>
</template>

<script setup>
import {ref, computed} from 'vue'
const value = ref('this is a value')

// 注意这里
const reversedValue = computed(() => {
// 使用 ref 需要 .value
return value.value
.split('').reverse().join('');
})

</script>

6、watch


这一部分,我们需要注意一下了,Vue3 中,watch 有两种写法。一种是直接使用 watch,还有一种是使用 watchEffect


两种写法的区别是:




  • watch 需要你明确指定依赖的变量,才能做到监听效果。




  • watchEffect 会根据你使用的变量,自动的实现监听效果。




1)直接使用 watch


// Vue2 的写法
<template>
<div>{{ count }}</div>
<div>{{ anotherCount }}</div>
<button @click="onClick">
增加 1
</button>
</template>

<script>
export default {
data() {
return {
count: 1,
anotherCount: 0,
};
},
methods: {
onClick() {
this.count += 1;
},
},
watch: {
count(newValue) {
this.anotherCount = newValue - 1;
},
},
}
</script>

// Vue3 的写法
<template>
<div>{{ count }}</div>
<div>{{ anotherCount }}</div>
<button @click="onClick">
增加 1
</button>
</template>

<script setup>
import { ref, watch } from 'vue';

const count = ref(1);
const onClick = () => {
count.value += 1;
};

const anotherCount = ref(0);

// 注意这里
// 需要在这里,
// 明确指定依赖的是 count 这个变量
watch(count, (newValue) => {
anotherCount.value = newValue - 1;
})

</script>

2)使用 watchEffect


// Vue2 的写法
<template>
<div>{{ count }}</div>
<div>{{ anotherCount }}</div>
<button @click="onClick">
增加 1
</button>
</template>

<script>
export default {
data() {
return {
count: 1,
anotherCount: 0,
};
},
methods: {
onClick() {
this.count += 1;
},
},
watch: {
count(newValue) {
this.anotherCount = newValue - 1;
},
},
}
</script>

// Vue3 的写法
<template>
<div>{{ count }}</div>
<div>{{ anotherCount }}</div>
<button @click="onClick">
增加 1
</button>
</template>

<script setup>
import { ref, watchEffect } from 'vue';

const count = ref(1);
const onClick = () => {
count.value += 1;
};

const anotherCount = ref(0);

// 注意这里
watchEffect(() => {
// 会自动根据 count.value 的变化,
// 触发下面的操作
anotherCount.value = count.value - 1;
})

</script>

7、生命周期


Vue3 里,除了将两个 destroy 相关的钩子,改成了 unmount,剩下的需要注意的,就是在 <script setup> 中,不能使用 beforeCreatecreated 两个钩子。


如果你熟悉相关的生命周期,只需要记得在 setup 里,用 on 开头,加上大写首字母就行。


// 选项式 api 写法
<template>
<div></div>
</template>

<script>
export default {
beforeCreate() {},
created() {},

beforeMount() {},
mounted() {},

beforeUpdate() {},
updated() {},

// Vue2 里叫 beforeDestroy
beforeUnmount() {},
// Vue2 里叫 destroyed
unmounted() {},

// 其他钩子不常用,所以不列了。
}
</script>

// 组合式 api 写法
<template>
<div></div>
</template>


<script setup>
import {
onBeforeMount,
onMounted,

onBeforeUpdate,
onUpdated,

onBeforeUnmount,
onUnmounted,
} from 'vue'

onBeforeMount(() => {})
onMounted(() => {})

onBeforeUpdate(() => {})
onUpdated(() => {})

onBeforeUnmount(() => {})
onUnmounted(() => {})
</script>

三、结语


好了,对于快速上手 Vue3 来说,以上内容基本已经足够了。


这篇文章本身不能做到帮你理解所有 Vue3 的内容,但是能帮你快速掌握 Vue3 的写法。


如果想做到对 Vue3 的整个内容心里有数,还需要你自己多看看 V

作者:Wetoria
来源:juejin.cn/post/7225267685763907621
ue3 的官方文档。

收起阅读 »

九个超级好用的 Javascript 技巧

web
作者:shichuan 文末彩蛋等你揭晓 🤫 前言 在实际的开发工作过程中,积累了一些常见又超级好用的 Javascript 技巧和代码片段,包括整理的其他大神的 JS 使用技巧,今天筛选了 9 个,以供大家参考。 1、动态加载 JS 文件 在一些特殊的场景...
继续阅读 »

作者:shichuan


文末彩蛋等你揭晓 🤫



前言


在实际的开发工作过程中,积累了一些常见又超级好用的 Javascript 技巧和代码片段,包括整理的其他大神的 JS 使用技巧,今天筛选了 9 个,以供大家参考。


1、动态加载 JS 文件


在一些特殊的场景下,特别是一些库和框架的开发中,我们有时会去动态的加载 JS 文件并执行,下面是利用 Promise 进行了简单的封装。


function loadJS(files, done) {
// 获取head标签
const head = document.getElementsByTagName('head')[0];
Promise.all(files.map(file => {
return new Promise(resolve => {
// 创建script标签并添加到head
const s = document.createElement('script');
s.type = "text/javascript";
s.async = true;
s.src = file;
// 监听load事件,如果加载完成则resolve
s.addEventListener('load', (e) => resolve(), false);
head.appendChild(s);
});
})).then(done); // 所有均完成,执行用户的回调事件
}

loadJS(["test1.js", "test2.js"], () => {
// 用户的回调逻辑
});

上面代码核心有两点,一是利用 Promise 处理异步的逻辑,而是利用 script 标签进行 js 的加载并执行。


2、实现模板引擎


下面示例用了极少的代码实现了动态的模板渲染引擎,不仅支持普通的动态变量的替换,还支持包含 for 循环,if 判断等的动态的 JS 语法逻辑,具体实现逻辑在笔者另外一篇文章《面试官问:你能手写一个模版引擎吗?》做了非常详详尽的说明,感兴趣的小伙伴可自行阅读。


// 这是包含了js代码的动态模板
var template =
'My avorite sports:' +
'<%if(this.showSports) {%>' +
'<% for(var index in this.sports) { %>' +
'<a><%this.sports[index]%></a>' +
'<%}%>' +
'<%} else {%>' +
'<p>none</p>' +
'<%}%>';
// 这是我们要拼接的函数字符串
const code = `with(obj) {
var r=[];
r.push("My avorite sports:");
if(this.showSports) {
for(var index in this.sports) {
r.push("<a>");
r.push(this.sports[index]);
r.push("</a>");
}
} else {
r.push("<span>none</span>");
}
return r.join("");
}`

// 动态渲染的数据
const options = {
sports: ["swimming", "basketball", "football"],
showSports: true
}
// 构建可行的函数并传入参数,改变函数执行时this的指向
result = new Function("obj", code).apply(options, [options]);
console.log(result);

3、利用 reduce 进行数据结构的转换


有时候前端需要对后端传来的数据进行转换,以适配前端的业务逻辑,或者对组件的数据格式进行转换再传给后端进行处理,而 reduce 是一个非常强大的工具。


const arr = [
{ classId: "1", name: "张三", age: 16 },
{ classId: "1", name: "李四", age: 15 },
{ classId: "2", name: "王五", age: 16 },
{ classId: "3", name: "赵六", age: 15 },
{ classId: "2", name: "孔七", age: 16 }
];

groupArrayByKey(arr, "classId");

function groupArrayByKey(arr = [], key) {
return arr.reduce((t, v) => (!t[v[key]] && (t[v[key]] = []), t[v[key]].push(v), t), {})
}

很多很复杂的逻辑如果用 reduce 去处理,都非常的简洁。


4、添加默认值


有时候一个方法需要用户传入一个参数,通常情况下我们有两种处理方式,如果用户不传,我们通常会给一个默认值,亦或是用户必须要传一个参数,不传直接抛错。


function double() {
return value *2
}

// 不传的话给一个默认值0
function double(value = 0) {
return value * 2
}

// 用户必须要传一个参数,不传参数就抛出一个错误

const required = () => {
throw new Error("This function requires one parameter.")
}
function double(value = required()) {
return value * 2
}

double(3) // 6
double() // throw Error

listen 方法用来创建一个 NodeJS 的原生 http 服务并监听端口,在服务的回调函数中创建 context,然后调用用户注册的回调函数并传递生成的 context。下面我们以前看下 createContext 和 handleRequest 的实现。


5、函数只执行一次


有些情况下我们有一些特殊的场景,某一个函数只允许执行一次,或者绑定的某一个方法只允许执行一次。


export function once (fn) {
// 利用闭包判断函数是否执行过
let called = false
return function () {
if (!called) {
called = true
fn.apply(this, arguments)
}
}
}

6、实现 Curring


JavaScript 的柯里化是指将接受多个参数的函数转换为一系列只接受一个参数的函数的过程。这样可以更加灵活地使用函数,减少重复代码,并增加代码的可读性。


function curry(fn) {
return function curried(...args) {
if (args.length >= fn.length) {
return fn.apply(this, args);
} else {
return function(...args2) {
return curried.apply(this, args.concat(args2));
};
}
};
}

function add(x, y) {
return x + y;
}

const curriedAdd = curry(add);

console.log(curriedAdd(1)(2)); // 输出 3
console.log(curriedAdd(1, 2)); // 输出 3

通过柯里化,我们可以将一些常见的功能模块化,例如验证、缓存等等。这样可以提高代码的可维护性和可读性,减少出错的机会。


7、实现单例模式


JavaScript 的单例模式是一种常用的设计模式,它可以确保一个类只有一个实例,并提供对该实例的全局访问点,在 JS 中有广泛的应用场景,如购物车,缓存对象,全局的状态管理等等。


let cache;
class A {
// ...
}

function getInstance() {
if (cache) return cache;
return cache = new A();
}

const x = getInstance();
const y = getInstance();

console.log(x === y); // true

8、实现 CommonJs 规范


CommonJS 规范的核心思想是将每个文件都看作一个模块,每个模块都有自己的作用域,其中的变量、函数和对象都是私有的,不能被外部访问。要访问模块中的数据,必须通过导出(exports)和导入(require)的方式。


// id:完整的文件名
const path = require('path');
const fs = require('fs');
function Module(id){
// 用来唯一标识模块
this.id = id;
// 用来导出模块的属性和方法
this.exports = {};
}

function myRequire(filePath) {
// 直接调用Module的静态方法进行文件的加载
return Module._load(filePath);
}

Module._cache = {};
Module._load = function(filePath) {
// 首先通过用户传入的filePath寻址文件的绝对路径
// 因为再CommnJS中,模块的唯一标识是文件的绝对路径
const realPath = Module._resoleveFilename(filePath);
// 缓存优先,如果缓存中存在即直接返回模块的exports属性
let cacheModule = Module._cache[realPath];
if(cacheModule) return cacheModule.exports;
// 如果第一次加载,需要new一个模块,参数是文件的绝对路径
let module = new Module(realPath);
// 调用模块的load方法去编译模块
module.load(realPath);
return module.exports;
}

// node文件暂不讨论
Module._extensions = {
// 对js文件处理
".js": handleJS,
// 对json文件处理
".json": handleJSON
}

function handleJSON(module) {
// 如果是json文件,直接用fs.readFileSync进行读取,
// 然后用JSON.parse进行转化,直接返回即可
const json = fs.readFileSync(module.id, 'utf-8')
module.exports = JSON.parse(json)
}

function handleJS(module) {
const js = fs.readFileSync(module.id, 'utf-8')
let fn = new Function('exports', 'myRequire', 'module', '__filename', '__dirname', js)
let exports = module.exports;
// 组装后的函数直接执行即可
fn.call(exports, exports, myRequire, module,module.id,path.dirname(module.id))
}

Module._resolveFilename = function (filePath) {
// 拼接绝对路径,然后去查找,存在即返回
let absPath = path.resolve(__dirname, filePath);
let exists = fs.existsSync(absPath);
if (exists) return absPath;
// 如果不存在,依次拼接.js,.json,.node进行尝试
let keys = Object.keys(Module._extensions);
for (let i = 0; i < keys.length; i++) {
let currentPath = absPath + keys[i];
if (fs.existsSync(currentPath)) return currentPath;
}
};

Module.prototype.load = function(realPath) {
// 获取文件扩展名,交由相对应的方法进行处理
let extname = path.extname(realPath)
Module._extensions[extname](this)
}

上面对 CommonJs 规范进行了简单的实现,核心解决了作用域的隔离,并提供了 Myrequire 方法进行方法和属性的加载,对于上面的实现,笔者专门有一篇文章《38 行代码带你实现 CommonJS 规范》进行了详细的说明,感兴趣的小伙伴可自行阅读。


9、递归获取对象属性


如果让我挑选一个用的最广泛的设计模式,我会选观察者模式,如果让我挑一个我所遇到的最多的算法思维,那肯定是递归,递归通过将原始问题分割为结构相同的子问题,然后依次解决这些子问题,组合子问题的结果最终获得原问题的答案。


const user = {
info: {
name: "张三",
address: { home: "Shaanxi", company: "Xian" },
},
};

// obj是获取属性的对象,path是路径,fallback是默认值
function get(obj, path, fallback) {
const parts = path.split(".");
const key = parts.shift();
if (typeof obj[key] !== "undefined") {
return parts.length > 0 ?
get(obj[key], parts.join("."), fallback) :
obj[key];
}
// 如果没有找到key返回fallback
return fallback;
}

console.log(get(user, "info.name")); // 张三
console.log(get(user, "info.address.home")); // Shaanxi
console.log(get(user, "info.address.company")); // Xian
console.log(get(user, "info.address.abc", "fallback")); // fallback

上面挑选了 9 个笔者认为比较有用的 JS 技巧,希望对大家有所帮助。


🎁 文末彩蛋 >>


码上掘金编程比赛火热进行中,同时为大家推出「报名礼 & 完赛奖」活动~

报名即有机会瓜分上百万掘金矿石奖池!提交作品更可参与精美奖品的抽取哦!


🎁 抽奖攻略请戳这里

🎡 更多大赛特别活动请看这里




尾部关注.gif


扫码关注公众号 👆 追更不迷路


作者:字节前端
来源:juejin.cn/post/7223938976158957624
收起阅读 »

用CSS给健身的女朋友做一个喝水记录本

web
我报名参加金石计划1期挑战——瓜分10万奖池,这是我的第2篇文章,点击查看活动详情 前言 事情是这样的,由于七八月份的晚上时不时就坐在地摊上开始了喝酒撸串的一系列放肆的长肉肉项目。 这不,前段时间女朋友痛下决心(心血来潮)地就去报了一个健身的私教班,按照教练给...
继续阅读 »

我报名参加金石计划1期挑战——瓜分10万奖池,这是我的第2篇文章,点击查看活动详情


前言


事情是这样的,由于七八月份的晚上时不时就坐在地摊上开始了喝酒撸串的一系列放肆的长肉肉项目。
这不,前段时间女朋友痛下决心(心血来潮)地就去报了一个健身的私教班,按照教练给的饮食计划中,其中有一项是每天需要喝 2.6L 的水来促进体内的新陈代谢。
作为伴侣肯定要十分支持的呀,不过因为平时工作也是十分费脑筋的,不会专门去记录每天喝了多少水,特别容易忘记。所以做了这个喝水记录本给她。


开发需求


整体的开发需求和前言里描述的差不多,整体功能拆分一下就非常清晰了。


一、定义变量



  1. 大杯子:我们需要一个总量目标,用于定义每天的计划值。

  2. 小杯子:一个单次目标,我们不会一次接一大桶水来喝,即使用小杯子喝水时,每个杯子的刻度值。


二、逻辑整合



  1. 点击每个小杯子时,从大杯子的总量中扣除小杯子的刻度并记录,对应UI水位升高。

  2. 首次点击小杯子时,展示百分率刻度值,提升水位。

  3. 当完成目标值后,隐藏剩余水量的文字。

  4. "清空"按钮,消除本地记录值,恢复UI水位,展示剩余量。


创建流程和主要代码


 此模块代码是应用于小程序使用的,所以代码部分使用wx框架。(下面有普通代码部分)


wxml


构造整体布局,布局和制作大杯子和小杯子。


在上一段开发需求部分中提到的隐藏内容时,注意不要使用 wx:if 直接删除整个标签,这样会导致画面跳动,无法实现动画的平滑过渡。


用三元运算符隐藏文字可以实现较好的过渡


<view class="body">
<text class="h1">喝水记录本</text>
<text class="h3">今日目标: 2.6升 </text>

<view class="cup">
<view class="remained" style="height: {{remainedH}}px">
<text class="span">{{isRemained ? liters : ''}}</text>
<text class="small">{{isRemained ? '剩余' : ''}}</text>
</view>

<view class="percentage" style="{{percentageH}}">{{isPercentage ? percentage : ''}}</view>
</view>

<text class="text">请选择喝水的杯子</text>

<view class="cups">
<view class="cup cup-small" bindtap="cups" data-ml="700">700 ml</view>
<view class="cup cup-small" bindtap="cups" data-ml="400">400 ml</view>
<view class="cup cup-small" bindtap="cups" data-ml="600">600 ml</view>
<view class="cup cup-small" bindtap="cups" data-ml="500">500 ml</view>
<view class="cup cup-small" bindtap="cups" data-ml="50">50 ml</view>
<view class="cup cup-small" bindtap="cups" data-ml="100">100 ml</view>
<view class="cup cup-small" bindtap="cups" data-ml="150">150 ml</view>
<view class="cup cup-small" bindtap="cups" data-ml="300">300 ml</view>
</view>

<view class="cancle" bindtap="update">清空</view>
</view>

wxss


css就是简单的画杯子和布局,值得说的就是往大杯子里加水的动画 transition 一下就可以了


.body {
height: 108vh;
background-color: #3494e4;
color: #fff;
display: flex;
flex-direction: column;
align-items: center;
box-sizing: border-box;
}

.h1 {
margin: 10px 0 0;
}

.h3 {
font-weight: 400;
margin: 10px 0;
}

.cup {
background-color: #fff;
border: 4px solid #144fc6;
color: #144fc6;
border-radius: 0 0 40px 40px;
height: 330px;
width: 150px;
margin: 30px 0;
display: flex;
flex-direction: column;
overflow: hidden;
}

.cup.cup-small {
height: 95px;
width: 50px;
border-radius: 0 0 15px 15px;
background-color: rgba(255, 255, 255, 0.9);
cursor: pointer;
font-size: 14px;
align-items: center;
justify-content: center;
text-align: center;
margin: 5px;
transition: 0.3s ease;
}

.cup.cup-small.full {
background-color: #6ab3f8;
color: #fff;
}

.cups {
display: flex;
flex-wrap: wrap;
align-items: center;
justify-content: center;
width: 280px;
}

.remained {
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
text-align: center;
flex: 1;
transition: 0.3s ease;
}

.remained .span {
font-size: 20px;
font-weight: bold;
}

.remained .small {
font-size: 12px;
}

.percentage {
background-color: #6ab3f8;
display: flex;
align-items: center;
justify-content: center;
font-weight: bold;
font-size: 30px;
height: 0;
transition: 0.3s ease;
box-sizing: border-box;
}

.text {
text-align: center;
margin: 0 0 5px;
}

.cancle {
cursor: pointer;
}

js


逻辑注释写在了代码中


Page({
data: {
liters: '2.6L',
isPercentage: true,
isRemained: true,
percentage: '',
percentageH: 'height: 0',
RemainedH: 0,
goal: 2600
},

// 每次进入页面后加载记录的值,执行动画
onShow() {
this.setData({ goal: Number(wx.getStorageSync('goal')) })
this.updateBigCup(2600 - this.data.goal)
},

// 点击小杯子时的触发逻辑
cups(data) {
const ml = Number(data.currentTarget.dataset.ml);
const goal = this.data.goal - ml;
const total = 2600 - goal;
this.setData({ goal })
wx.setStorageSync("goal", goal);
this.updateBigCup(total)
},

// 更新 UI 数据
updateBigCup(total) {
const { goal } = this.data;
if (goal != 2600) {
this.setData({
isPercentage: true,
percentage: `${(total / 2600 * 100).toFixed(0)}%`,
percentageH: `height: ${total / 2600 * 330}px`
})
}

if (goal <= 0) {
this.setData({
remainedH: 0,
isRemained: false,
})
} else {
this.setData({
isRemained: true,
liters: `${goal / 1000}L`
})
}
},

// 清空记录值
update() {
wx.removeStorage({ key: 'goal' })
this.setData({
goal: 2600,
isPercentage: false,
isRemained: true,
remainedH: 0,
percentageH: 'height: 0px',
liters: '2.6L'
})
}
})

码上掘金


  上面的代码部分主要用于小程序使用,码上掘金可在网页中使用。



结语


  感谢大家能看到这里!!本篇的代码本身没有什么技术含量,可能是比较会偏向实用性的一篇,对!是有一些的对吧!可以自己改装成Chrome插件使用会更方便更实用。啥?你问我为什么不直接写Chrome插件?有没有一种可能不是我不想,而是😭。


  好啦,如果你身边有健身的朋友也可以给他做

作者:dudoit
来源:juejin.cn/post/7147529288164573192
一个哦~再次谢谢大家

收起阅读 »

制作了一个图片像素风转换器

web
制作了一个图片像素风转换器,可以将图片转换成像素风格,并可转换为 css box-shadow 进行输出。前排先放效果图、转换器地址和 GitHub 地址: 转化器地址:pixel.heyfe.org/ GitHub 地址:github.com/ZxBing...
继续阅读 »

制作了一个图片像素风转换器,可以将图片转换成像素风格,并可转换为 css box-shadow 进行输出。前排先放效果图、转换器地址和 GitHub 地址:


blog-mosaic-converter-44.gif


转化器地址:pixel.heyfe.org/


GitHub 地址:github.com/ZxBing0066/…


转换器功能


转换器会将传入的图片转换为像素风格,并将像素风格的图片以 box-shadow 进行转换,借助 box-shadow,我们可以直接用 css 来渲染该图片,且可以通过 box-shadow 的一些特性来达成一些比较好玩的效果,比如用间隙来加重像素风格:


blog-mosaic-converter-84.png


或者直接将间隙拉到顶,达成类似点阵图的效果:


blog-mosaic-converter-55.png


又或者借助 border-radius,实现圆点图效果:


blog-mosaic-converter-71.png


制作出想要的效果后,可以在右侧点击 复制 box-shadow 样式 按钮复制其样式。


实现原理


关于 box-shadow 实现像素图的原理之前有一篇文章中有提到,这里不再赘述。此处大概说一下图片转换为像素图再转为 box-shadow 的过程。


转换器在拿到图片后,会将图片绘制在一个非常小的画布中,以此来降低图片的精度,然后将画布中绘制的低精度图片进行二次渲染,渲染到较大的画布中,此时由于图片被拉伸,就会形成一定的像素效果。随后为了将像素效果图转换为 box-shadow,转换器会去读取画布中的绘制信息,将其生成为一组二维数组,再根据其中的颜色转换为 box-shadow 中的属性。至此转换器的功能就完成了。


当然其中还有一些细节(浏览器会默认启用平滑绘制导致像素效果消失等问题),本篇不打算细说,会在下篇专门写一篇来讲一下具体实现。


最后


本转换器原先是在码上掘金挑战赛某次文章中构想 ,然后在第二次制作类似效果时干脆使用脚本来完成了,最近有空就将其稍微优化了一下进行开源。目前一些细节还有点欠缺,待改进。


再贴一下地址:


转化器地址:pixel.heyfe.org/


GitHub 地址:github.com/ZxBing0066/…


相关文章



作者:嘿嘿Z
来源:juejin.cn/post/7150465824690536484
收起阅读 »

【记】滑动拼图验证码在搜索中的作用

开头验证码应用于我们生活、工作的方方面面,比如注册登录账号、支付订单、修改密码等。下面我是在一次项目中利用滑动拼图验证码和搜索功能“合作共赢”的记录。验证码展示具体实现前端代码// 引入js<script src="captcha.js?appid=XX...
继续阅读 »

开头

验证码应用于我们生活、工作的方方面面,比如注册登录账号、支付订单、修改密码等。下面我是在一次项目中利用滑动拼图验证码和搜索功能“合作共赢”的记录。

验证码展示



具体实现

前端代码

// 引入js
<script src="captcha.js?appid=XXX"></script>
<script>
kg.captcha({
// 绑定弹窗按钮
button: "#captchaButton",

// 验证成功事务处理
success: function (e) {
// 验证成功,直接提交表单
// form1.submit();
console.log(e);
},

// 验证失败事务处理
failure: function (e) {
console.log(e);
},

// 点击刷新按钮时触发
refresh: function (e) {
console.log(e);
}
});
</script>

<a id="captchaButton"></a>


验证结果说明


 

字段名
数据类型   描述   
 

code
 

number
 

返回code信息
 

msg
 

string
 

验证结果信息
 

rid
 

number
 

用户的验证码应用id
 

sense
 

number
 

是否开启无感验证,0-关闭,1-开启
 

token
 

string
 

验证成功才有:token
 

weight
 

number
 

错误严重性,0正常错误,可以继续操作,1一般错误,刷新/重新加载拼图,2严重错误,错误次数过多拒绝访问


Python代码

from wsgiref.simple_server import make_server
from KgCaptchaSDK import KgCaptcha
def start(environ, response):
# 填写你的 AppId,在应用管理中获取
AppID = "AppId"
# 填写你的 AppSecret,在应用管理中获取
AppSecret = "AppSecret"
request = KgCaptcha(AppID, AppSecret)
# 填写应用服务域名,在应用管理中获取
request.appCdn = "https://cdn.kgcaptcha.com"
# 请求超时时间,秒
request.connectTimeout = 10
# 用户id/登录名/手机号等信息,当安全策略中的防控等级为3时必须填写
request.userId = "kgCaptchaDemo"
# 使用其它 WEB 框架时请删除 request.parse,使用框架提供的方法获取以下相关参数
parseEnviron = request.parse(environ)
# 前端验证成功后颁发的 token,有效期为两分钟
request.token = parseEnviron["post"].get("kgCaptchaToken", "") # 前端 _POST["kgCaptchaToken"]
# 客户端IP地址
request.clientIp = parseEnviron["ip"]
# 客户端浏览器信息
request.clientBrowser = parseEnviron["browser"]
# 来路域名
request.domain = parseEnviron["domain"]
# 发送请求
requestResult = request.sendRequest()
if requestResult.code == 0:
# 验证通过逻辑处理
html = "验证通过"
else:
# 验证失败逻辑处理
html = f"{requestResult.msg} - {requestResult.code}"
response("200 OK", [("Content-type", "text/html; charset=utf-8")])
return [bytes(str(html), encoding="utf-8")]
httpd = make_server("0.0.0.0", 8088, start) # 设置调试端口 http://localhost:8088/
httpd.serve_forever()


最后

SDK开源地址:KgCaptcha (KgCaptcha) · GitHub,顺便做了一个演示:凯格行为验证码在线体验

收起阅读 »

仿抖音左右歪头图片选择

web
在线体验 项目 github 仓库 前一阵子在刷抖音时,看到一个通过左右歪头选择两侧图片的视频,感觉很有趣。顿时想到了 n 年前的face-api.js,那就基于这个来做吧。总体做好后,有很多细节需要改进,不够细腻丝滑。 1. 需求分析 直接开搞吧! ...
继续阅读 »

在线体验


项目 github 仓库


ezgif-4-7883a8f8e5.gif



前一阵子在刷抖音时,看到一个通过左右歪头选择两侧图片的视频,感觉很有趣。顿时想到了 n 年前的face-api.js,那就基于这个来做吧。总体做好后,有很多细节需要改进,不够细腻丝滑。



1. 需求分析


直接开搞吧!



  1. 页面基本布局,左右两侧图片,而且有缩放和移动动画

  2. 需要打开摄像头,获取视频流,通过 video 展现出来

  3. 需要检测人脸是向哪一侧歪头


2. 具体实现


2.1 页面布局和 animation 动画


这个不难,布局好后,就是添加 css 动画,我这里写的很粗糙,不细腻,但勉强能用,例如下面 leftHeartMove 为中间的小爱心向左侧移动动画


.heart {
width: 30px;
height: 30px;
padding: 4px;
box-sizing: border-box;
border-radius: 50%;
background-color: #fff;
position: absolute;
top: -15px;
left: 50%;
transform: translateX(-50%) rotateZ(0deg) scale(1);
animation: leftHeartMove 0.5s linear;
animation-fill-mode: forwards;
z-index: 2;
}

@keyframes leftHeartMove {
from {
top: -15px;
left: 50%;
transform: translateX(-50%) rotateZ(0deg) scale(1);
}

to {
top: 65px;
left: -13%;
transform: translateX(-50%) rotateZ(-15deg) scale(1.2);
}
}

2.2 打开摄像头并显示


注意点



  1. 关于 h5navigator.mediaDevices.getUserMedia 这个 api,本地开发localhost是可以拉起摄像头打开提示的,线上部署必须是https节点才行,http不能唤起打开摄像头


WX20221128-221028@2x.png




  1. 关于获取到视频流后,video视频播放,需要镜面翻转,这个可以通过 css 的transform: rotateY(180deg)来翻转




  2. 关于video播放不能在手机上竖屏全屏,可以给 video 设置 cssobject-fit:cover来充满屏幕




<video id="video" class="video" playsinline autoplay muted></video>

.video {
width: 100%;
height: 100%;
transform: rotateY(180deg);
object-fit: cover;
}


  • 获取摄像头视频流


async getUserMedia() {
if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) {
try {
// https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia#examples
const stream = await navigator.mediaDevices.getUserMedia({
audio: false,
video: true,
video: {
facingMode: "user", // 前置摄像头
// facingMode: { exact: "environment" },// 后置摄像头
width: { min: 1280, max: 1920 },
height: { min: 720, max: 1080 },
},
});

return Promise.resolve(stream);
} catch (error) {
return Promise.reject();
}
}

const errorMessage =
"This browser does not support video capture, or this device does not have a camera";
alert(errorMessage);
}


  • video 播放视频流


async openCamera(e) {
try {
const stream = await this.getUserMedia();
this.video.srcObject = stream;
this.video.onloadedmetadata = async () => {
this.video.play();
};
} catch (error) {
console.log(error);
alert("打开摄像头失败");
}
}


  • 关闭视频


async closeCamera() {
// https://developer.mozilla.org/en-US/docs/Web/API/MediaStreamTrack/stop
const tracks = this.video.srcObject.getTracks();

tracks.forEach((track) => {
track.stop();
});

this.video.srcObject.srcObject = null;
}

2.3 检测人脸左右倾斜


landmarks.png


通过face-api.js拿到人脸landmarks特征数据后,可以直接拿到左右眼的数据,分别通过求 Y 轴方向的平均值,然后比较这个平均值,便可以简单得出人脸向左还是向右倾斜,简单吧,角度都不用求了!


<div style="position: relative;width: 100%;height: 100%;">
<video
id="video"
class="video"
playsinline
autoplay
muted
style="object-fit:cover"
>
</video>
<canvas id="overlay" class="overlay"></canvas>
</div>

.video {
width: 100%;
height: 100%;
position: absolute;
top: 0;
left: 0;
z-index: 0;
transform: rotateY(180deg);
}

.overlay {
position: absolute;
top: 0;
left: 0;
}


  • 加载模型


import * as faceapi from "face-api.js";

async loadWeight() {
// 加载模型
await faceapi.nets.ssdMobilenetv1.load(
"./static/weights/ssd_mobilenetv1_model-weights_manifest.json"
);
// 加载人脸68特征模型数据
await faceapi.nets.faceLandmark68Net.load(
"./static/weights/face_landmark_68_model-weights_manifest.json"
);
// await faceapi.nets.faceExpressionNet.load(
// "/static/weights/face_expression_model-weights_manifest.json"
// );
// await faceapi.nets.faceRecognitionNet.load(
// "./static/weights/face_recognition_model-weights_manifest.json"
// );
await faceapi.nets.ageGenderNet.load(
"./static/weights/age_gender_model-weights_manifest.json"
);

console.log("模型加载完成");
}


  • 计算人脸左右倾斜


handleFaceLeftOrRight(landmarks) {
const DIFF_NUM = 15; // 偏差
let leftEye = landmarks.getLeftEye(); // 左眼数据
let rightEye = landmarks.getRightEye(); // 右眼数据
// let nose = landmarks.getNose();

let leftEyeSumPoint = leftEye.reduce((prev, cur) => ({
x: prev.x + cur.x,
y: prev.y + cur.y,
}));

let rightEyeSumPoint = rightEye.reduce((prev, cur) => ({
x: prev.x + cur.x,
y: prev.y + cur.y,
}));

// let noseSumPoint = nose.reduce((prev, cur) => ({
// x: prev.x + cur.x,
// y: prev.y + cur.y,
// }));

let leftEyeAvgPoint = {
x: leftEyeSumPoint.x / leftEye.length,
y: leftEyeSumPoint.y / leftEye.length,
};

let rightEyeAvgPoint = {
x: rightEyeSumPoint.x / leftEye.length,
y: rightEyeSumPoint.y / leftEye.length,
};

// let noseAvgPoint = {
// x: noseSumPoint.x / leftEye.length,
// y: noseSumPoint.y / leftEye.length,
// };

// console.log(leftEyeAvgPoint, rightEyeAvgPoint, noseAvgPoint);
let diff = Math.abs(leftEyeAvgPoint.y - rightEyeAvgPoint.y);

return diff > DIFF_NUM
? leftEyeAvgPoint.y > rightEyeAvgPoint.y
? "left"
: "right"
: "center";
}


  • 处理 video 视频


async handleVideoFaceTracking(cb) {
if (this.closed) {
window.cancelAnimationFrame(this.raf);
return;
}

const options = new faceapi.SsdMobilenetv1Options();

let task = faceapi.detectAllFaces(this.video, options);
task = task.withFaceLandmarks().withAgeAndGender();
const results = await task;

// overlay为canvas元素
// video即为video元素
const dims = faceapi.matchDimensions(this.overlay, this.video, true);
const resizedResults = faceapi.resizeResults(results, dims);

// console.log("options==>", options);
// console.log("resizedResults==>", resizedResults);
cb && cb(resizedResults);

this.raf = requestAnimationFrame(() => this.handleVideoFaceTracking(cb));
}

3. 参考资料




  1. face-api.js




  2. getUserMedia MDN




作者:sRect
来源:juejin.cn/post/7171081395551338503
收起阅读 »

假如:a===1 && a===2 && a===3; 那么 a 是什么?

web
前言 文章提供视频版啦,点击直接查看 hello,大家好,我是 sunday。 今天遇到了一个非常有意思的问题,跟大家分享一下。 咱们来看这段代码: a===1 && a===2 && a===3 假设上面的表达式成立,...
继续阅读 »

前言



文章提供视频版啦,点击直接查看



hello,大家好,我是 sunday


今天遇到了一个非常有意思的问题,跟大家分享一下。


咱们来看这段代码:


a===1 && a===2 && a===3 

假设上面的表达式成立,那么问:a 是什么?


正文


ok,我们来说一下这个问题的解答。


想要解决这个问题,那么我们首先要知道 JavaScript 中的类型转换和比较运算符的优先级。


JavaScript 中,表达式的运算顺序是 从左到右。因此,在这个表达式中,先执行 a===1 的比较运算符,如果它返回 false,整个表达式就会返回 false,也就是逻辑中断。


如果 a 的值是 1,则比较运算符返回 true,那么就会继续执行下一个逻辑运算符 &&,接着执行 a===2 的比较运算符,如果它返回 false,则整个表达式返回 false,逻辑中断。


以此类推,以此类推,所以 a 的值应该是动态变化的,并且应该依次为 1、2、3。只有这样才会出现 a===1 && a===2 && a===3; 返回 true 的情况。


那么 如何让 a 的值动态变化,就是咱们解决这个问题的关键。


我们在 一小时读完《JavaScript权威指南(第7版)》上一小时读完《深入理解现代 JavaScript》,彻底掌握 ES6 之后 JavaScript 新特性! 中都讲到过,对象的方法存在 get 标记,一旦方法存在 get 标记,那么我们就可以像调用对象的属性一样,调用这个方法。


那么说到这里,肯定很多小伙伴都想到这个问题怎么解决了。


我们直接来看代码:


 const obj = {
 // get 标记
 get a() {
   this.value = this.value || 1;
   return this.value++;
}
};

console.log(obj.a === 1 && obj.a === 2 && obj.a === 3); // true

在这段代码中,我们创建了一个对象 obj,它包含一个被 get 标记的方法 a。那么此时只要执行 obj.a 就会调用 a 方法,完成 value 自增的操作。从而得到咱们期望的结果。


总结


这是一个非常有意思的问题。除了上面这种方案之后,还有很多其他的实现方案。大家可以开动脑筋,想一想别的方案都有什么呢?


答案留在评论区,咱们

作者:LGD_Sunday
来源:juejin.cn/post/7223586933881421861
一起来讨论下哦~~~

收起阅读 »

浅析小程序蓝牙技术

web
认识蓝牙 蓝牙技术是一种无线数据和语音通信开放的全球规范,它是基于低成本的近距离无线连接,为固定和移动设备建立通信环境的一种特殊的近距离无线技术连接。 传统蓝牙和低功耗蓝牙 根据蓝牙的发展历程,将蓝牙普遍分为两种规格,即传统蓝牙模块(BT) 和低功耗蓝牙模...
继续阅读 »

认识蓝牙



蓝牙技术是一种无线数据和语音通信开放的全球规范,它是基于低成本的近距离无线连接,为固定和移动设备建立通信环境的一种特殊的近距离无线技术连接。



传统蓝牙和低功耗蓝牙


根据蓝牙的发展历程,将蓝牙普遍分为两种规格,即传统蓝牙模块(BT)低功耗蓝牙模块(BLE)。传统蓝牙模块常用在对数据传输带宽有一定要求的场景上。低功耗蓝牙是从蓝牙4.0起支持的协议,特点是耗电极低、传输速度更快,常用在对续航要求较高且只需小数据量传输的各种智能电子产品中。


技术指标经典蓝牙BT低功耗蓝牙BLE
无线电频率2.4GHz2.4GHz
距离10米最大100米
发送数据所需时间100ms<3ms
响应延时约100ms6ms
安全性64/128-bit及用户自定义的应用层128-bitAES及用户自定义的应用层
能耗100%(ref)1%-50%
空中传输数据速率1-3Mb/s1Mb/s
主要用途手机,游戏机,耳机,音箱,汽车和PC等鼠标,键盘,手表,体育健身,医疗保健,智能穿戴设备,汽车,家用电子等
适用场景较高数据量传输、对传输带宽有要求续航要求较高、数据量小

蓝牙技术目前已经发展到5.0+版本,为现阶段最高级的蓝牙协议标准。BLE技术更契合新时代物联网的需求:更快、更省、更远、更便捷,也是我们小程序开发者在物联网项目最常用的技术。


蓝牙通信概述


低功耗蓝牙协议给设备定义了若干角色,其中最主要的角色是:外围设备(Peripheral)中心设备(Central)。




  • 外围设备:用来提供数据,通过不停地向外广播数据,让中心设备发现自己。




  • 中心设备:扫描外围设备,发现有外围设备存在后,可以与之建立连接,之后就可以使用外围设备提供的服务(Service)。




在两个蓝牙设备建立连接之后,双方的数据交互是基于一个叫做 GATT (Generic Attribute Profile,通用属性配置文件) 的规范,根据该规范可以定义出一个配置文件(Profile),描述该蓝牙设备提供的服务(Service)。


在整个通信过程中,有三个最主要的概念:配置文件(Profile)服务(Service)特征(Characteristic)


Characteristic:在 GATT 规范中最小的逻辑数据单元。实际上,在与蓝牙设备打交道,主要就是通过读写 Characteristic 的 value 完成。Characteristic 是通过一个 16bit 或 128bit 的 UUID 唯一标识。


Service:可以理解为蓝牙设备提供的服务,一个蓝牙设备可以提供多个服务,比如电量信息服务、系统信息服务等。每个 Service 又包含多个 Characteristic 特性值,比如电量信息服务就会有个 Characteristic 表示电量数据。同时也有一个 16bit 或 128bit 的 UUID 唯一标识该服务。


Profile:并不真实存在于蓝牙设备中,它只是被蓝牙标准预先定义的一些 Service 的集合。如果蓝牙设备之间要相互兼容,它们只要支持相同的 Profile 即可。一个蓝牙设备可以支持多个 Profile。


Desciptor: 描述符是描述特征值的已定义属性。例如,Desciptor 可指定人类可读的描述、特征值的取值范围或特定于特征值的度量单位。每个 Desciptor 由一个 UUID 唯一标识。


总结:每个蓝牙设备可能提供多个 Service,每个 Service 可能有多个 Characteristic,根据蓝牙设备的协议,用对应的 Characteristic 进行读写,即可达到与其通信的目的。


蓝牙开发实践


蓝牙通信过程介绍



整体上看,蓝牙通信的开发主要分为三部分:



  1. 蓝牙资源和状态管理:包括蓝牙生命周期管理、蓝牙状态管理(开关、适配器、设备连接、数据接收等)、错误异常处理。

  2. 搜寻外围设备并建立连接:包括搜寻设备、监听设备发现、处理获取到的设备信息、连接/断开设备等。

  3. 读写数据:包括寻找目标服务和特征值、订阅特征值、监听并接收设备数据、分包处理数据等。


蓝牙数据读写


在小程序蓝牙开发联调中,推荐使用TLV协议对数据进行封包,TLV协议(Tag、Length、Value)是常见的一种面向物联网的通讯协议,对于不同的传输场景,甚至演变出混合型、指针型、循环型等不同类型的格式。


比如,在实践中往往只需要最简单的L-TLV格式,以下使用十六进制(Hex)表示:



  • 数据包总长(L)

  • 数据的类型Tag/Type(T)

  • Value的长度Length(L)

  • 数据的值Value(V)


[0x07, 0x01, 0x01, 0x01, 0x02, 0x01, 0x01]
[数据总长,typelength,value,typelength,value]

举例


假设业务规定各字段type如下


字段名称type字段类型备注
account0x00String账号
Password0x01String密码

想要向设备传输一条写入account的指令,value为ABC。


ABC 通过 UTF-8 编码转 Hex String 分别是0x41、0x42、0x43。


那么数据包总长6字节,type是0,value总长3字节。


字符集编码


实际业务场景中,如果需要传输中文字符,则需要通过协商好的字符集进行转换。


常见字符集有:ASCII字符集、GB2312字符集、GBK字符集、 GB18030字符集、Unicode字符集等。


字符集描述
ASCII美国信息交换标准代码是基于拉丁字母的一套电脑编码系统,主要用于显示现代英语和其他西欧语言
GB2312中国人民通过对 ASCII 编码的中文扩充改造,产生了 GB2312 编码,可以表示6000多个常用汉字。
GBK汉字实在是太多了,包括繁体和各种字符,于是产生了 GBK 编码,它包括了 GB2312 中的编码,同时扩充了很多。
GB18030中国是个多民族国家,各个民族几乎都有自己独立的语言系统,为了表示那些字符,继续把 GBK 编码扩充为 GB18030 编码。
Unicode每个国家都像中国一样,把自己的语言进行编码,于是出现了各种各样的编码,如果你不安装相应的编码,就无法解释相应编码想表达的内容。终于,有个叫 ISO 的组织看不下去了。他们一起创造了一种编码 Unicode ,这种编码非常大,大到可以容纳世界上任何一个文字和标志。
UTF-8、 UTF-16Unicode 在网络传输中,出现了两个标准 UTF-8 和 UTF-16,分别每次传输 8个位和 16个位。

比如小写字母a,ASCII编码对应的Hex值是0x61,而GB2312字符集编码对应的Hex值是253631


将文本字符串转换为Hex字符串的时候,不同的字符集编码对应的Hex值不一样,所以小程序与蓝牙设备应当使用同一套字符集编码。推荐统一使用Unicode的UTF-8标准。


以下是字符转换示例:


// 中文转UTF-8
encodeURI('好').replace(/%/g, ''); // 'E5A5BD'

// UTF-8转中文
hex2String('E5A5BD'); // '好'

/**
* * read UTF-8
* @param { number[] } arr
* @returns {string}
*/

const readUTF = (arr: number [] ) => {
let UTF = '';
const _arr = arr;
for (let i = 0; i < _arr.length; i++) {
// 10进制转2进制
const one = _arr[i].toString(2);
const v = one.match(/^1+?(?=0)/);
if (v && one.length == 8) {
const bytesLength = v[0].length;
let store = _arr[i].toString(2).slice(7 - bytesLength);
for (let st = 1; st < bytesLength; st++) {
store += _arr[st + i].toString(2).slice(2);
}
// 二进制序列转charCode,再拼接
UTF += String.fromCharCode(parseInt(store, 2));
i += bytesLength - 1;
} else {
UTF += String.fromCharCode(_arr[i]);
}
}
return UTF;
};

/**
* * transfer hex to string
* @param { string } str
* @returns {string}
*/

const hex2String = (hex: string) => {
const buf = [];
// 转10进制数组
for (let i = 0; i < hex.length; i += 2) {
buf.push(parseInt(hex.substring(i, i + 2), 16));
}

return readUTF(buf);
};

蓝牙分包


但是实际场景往往不是传输几个字母这么简单。虽然小程序不会对写入数据包大小做限制,但与蓝牙设备传输数据时,数据量超过 MTU (最大传输单元) 容易导致系统错误,所以要主动对数据进行分片传输。


参考各小程序开放平台文档:


开放平台文档描述
微信小程序在与蓝牙设备传输数据时,需要注意 MTU(最大传输单元)。如果数据量超过 MTU 会导致错误,建议根据蓝牙设备协议进行分片传输。Android设备可以调用 wx.setBLEMTU 进行 MTU 协商。在 MTU 未知的情况下,建议使用 20 字节为单位传输。
飞书小程序蓝牙设备特征值对应的值,为 16 进制字符串,限制在 20 字节内
支付宝小程序写入特征值需要使用 16 进制的字符串,并限制在 20 字节内。
Taro小程序不会对写入数据包大小做限制,但系统与蓝牙设备会限制蓝牙4.0单次传输的数据大小,超过最大字节数后会发生写入错误,建议每次写入不超过20字节。若单次写入数据过长,iOS 上存在系统不会有任何回调的情况(包括错误回调)。

分包的过程,需要用到 ArrayBuffer



ArrayBuffer 对象用来表示通用的、固定长度的原始二进制数据缓冲区。


ArrayBuffer 是对固定长度的连续内存空间的引用。



在 Web 开发中,当我们处理文件时(创建,上传,下载),经常会遇到二进制数据。另一个典型的应用场景是图像处理。这些都可以通过 JavaScript 进行处理,而且二进制操作性能更高。


ArrayBuffer 只是一个内存区域,里面存储着一些原始的字节序列,它和普通的Array完全不是一个概念,它的长度是固定的,无法增加或减少,也无法直接用buffer[index]进行访问。


要想写入值、遍历它或者访问单个字节,需要使用视图(View) 进行操作,以下为一些常用的视图:


Uint8Array :将 ArrayBuffer 中的每个字节视为 0 到 255 之间的单个数字(每个字节是 8 位,因此只能容纳那么多)。称为 “8 位无符号整数”。


Uint16Array:将每 2 个字节视为一个 0 到 65535 之间的整数。称为 “16 位无符号整数”。


所有这些视图(Uint8Array,Uint32Array 等)的通用术语是 TypedArray(类型化数组)。它们都享有同一组方法和属性,类似于常规数组,具有索引,并且是可迭代的。


实际上,不同平台的小程序API定义的数据接口,都多少会用到ArrayBuffer



微信小程序-写入特征值



飞书小程序-获取设备信息


但也不排除有些操作,开发平台已经帮忙处理了



飞书小程序-写入特征值


因此学习并使用 ArrayBuffer,可以:




  1. 方便操作分包,方便读取设备返回的数据、向设备写入数据。




  2. 在不同小程序平台灵活处理,更好地兼容




回到主题,蓝牙分包的思路是:


Text String --> Hex String --> ArrayBuffer(分包)


举个例子,上文中想要向设备传输一条写入password的指令,value为bytedance123456789ABC


[数据总长,type,length,value] MTU为20字节
[0x14, 0x01, 0x11, 0x62, 0x79, 0x74, ...] 第一个包 bytedance12345678
[0x07, 0x01, 0x04, 0x39, 0x41, 0x42, ...] 第二个包 9ABC

设备端会将多个相同type的包的值追加,而不是覆盖。


如何与设备端协商分包交互机制?



  1. 规定服务、特征值UUID,建议不同操作使用不同的UUID,读、写、订阅分开。

  2. 遵循TLV协议,双方协商好Type对应的字段类型和含义。

  3. 双方使用同一套字符编码集。

  4. 约定连在一起的两次(或多次)相同类型的设置,应该把它们的值追加连接,而不是覆盖

  5. 可约定在一次涉及业务逻辑的通信过程中,发送“开始”和“结束”的蓝牙包,告知设备处于这两个信号之间的蓝牙包为一次完整的通信数据流。

  6. 双方共同约定一个超时时间,若在此时间内由于各种原因未能完成读/写通信,则认为通信失败,小程序端必须给予用户友好提示。


问题排查手段


在开发过程中可能会遇到调用API失败、连接断开等问题



  1. 检查API调用顺序


小程序的蓝牙API使用起来比较简单,但是需要严格遵循一定的调用顺序(参考上文的流程图)。比如检查是否在开关蓝牙适配器之外进行操作,或者是否在特征值发生变化后才进行事件监听等



  1. 对比测试



  • 业务小程序、开放平台官方蓝牙demo 对比

  • 开放平台(非微信)官方蓝牙demo、微信官方demo 对比

  • 同厂商设备、同芯片、同蓝牙模组,多台设备对比

  • iOS、Android,蓝牙调试软件 与小程序的对比 (iOS:LightBlue,Android:BLE调试宝、nRF Connect)


经过以上对比测试,基本可以缩小问题范围,定位问题究竟是出在哪一方。但并不百分之百准确。




  1. 一些Tips:



    • 设备Server端在自定义特征值UUID时未遵循GATT的Attribute Structure,而蓝牙服务iOS的实现会比Android更严格。

    • 外围设备使用deviceId作为唯一标识,但iOS 和 Android在拿到的信息上有所差异。Android上获取到的deviceId为设备MAC地址,iOS上则是系统根据外围设备 MAC 地址及发现设备的时间生成的 UUID,因此deviceId不能硬编码。

    • 蓝牙模块比较耗费系统资源,做好生命周期管理必不可少,比如建立连接和断开连接应该成对出现,如果未能及时关闭连接释放资源,容易导致连接异常。另外,大多数蓝牙模组只支持单链路,最大连接数量为1,若未能及时断开连接,必然出现设备搜寻不到或连接不上的情况。




  2. 日志排查




作为小程序的开发者,很多疑难问题往往不能直观看出。如果你有对应的资源可以联系到开放平台的维护人员,即可拿到日志。我们项目组曾与飞书开放平台建立蓝牙专项问题解决渠道,结合开平和设备端同学捕获的日志,可以加快排查速度。


参考文章


http://www.bluetooth.com/learn-about…
http://www.cnblogs.com/chusiyong/p…
http://www.jianshu.com/p/62eb2f540…
zh.javascript.info/arraybuffer…


作者:HenryZheng
来源:juejin.cn/post/7221794170868351034
收起阅读 »

HTML5+CSS3小实例:闪亮的玻璃图标悬浮效果

web
HTML5+CSS3实现闪亮的玻璃图标悬浮效果,光与玻璃的碰撞,好有质感的玻璃图标。 先看效果: 源代码: <!DOCTYPE html> <html> <head> <meta http-equiv="c...
继续阅读 »

HTML5+CSS3实现闪亮的玻璃图标悬浮效果,光与玻璃的碰撞,好有质感的玻璃图标。


先看效果:



源代码:


<!DOCTYPE html>
<html>

<head>
<meta http-equiv="content-type" content="text/html; charset=utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1,maximum-scale=1,user-scalable=no">

<title>闪亮的玻璃图标悬浮效果</title>
<link href="https://cdn.bootcdn.net/ajax/libs/font-awesome/4.7.0/css/font-awesome.css" rel="stylesheet">
<link rel="stylesheet" href="../css/5.css">
</head>

<body>
<div class="container">
<div class="color"></div>
<div class="color"></div>
<div class="color"></div>
<ul>
<li>
<a href="#"><i class="fa fa-qq" aria-hidden="true"></i></a>
</li>
<li>
<a href="#"><i class="fa fa-weixin" aria-hidden="true"></i></a>
</li>
<li>
<a href="#"><i class="fa fa-weibo" aria-hidden="true"></i></a>
</li>
<li>
<a href="#"><i class="fa fa-tencent-weibo" aria-hidden="true"></i></a>
</li>
<li>
<a href="#"><i class="fa fa-telegram" aria-hidden="true"></i></a>
</li>
</ul>
</div>
</body>

</html>

*{
margin: 0;
padding: 0;
/* 这个是告诉浏览器:你想要设置的边框和内边距的值是包含在总宽高内的 */
box-sizing: border-box;
}
body{
/* 溢出隐藏 */
overflow: hidden;
}
.container{
position: absolute;
width: 100%;
/* 100%窗口高度 */
height: 100vh;
/* 弹性布局 水平垂直居中 */
display: flex;
justify-content: center;
align-items: center;
/* 渐变背景 */
background: linear-gradient(to bottom,#2193b0,#6dd5ed);
}
.container::before{
content: "";
position: absolute;
bottom: 0px;
width: 100%;
height: 50%;
z-index: 1;
/* 背景模糊 */
backdrop-filter: blur(5px);
border-top: 1px solid rgba(255,255,255,0.5);
}
.container .color{
position: absolute;
/* 模糊滤镜 数值越大越模糊 */
filter: blur(200px);
}
.container .color:nth-child(1){
background-color: #fd746c;
width: 800px;
height: 800px;
top: -450px;
}
.container .color:nth-child(2){
background-color: #cf8bf3;
width: 600px;
height: 600px;
bottom: -150px;
left: 100px;
}
.container .color:nth-child(3){
background-color: #fdb99b;
width: 400px;
height: 400px;
bottom:50px;
right:100px;
}
ul{
position: relative;
display: flex;
z-index: 2;
}
ul li{
position: relative;
list-style: none;
margin: 10px;
}
ul li a{
position: relative;
width: 80px;
height: 80px;
display: inline-block;
border-radius: 10px;
display: flex;
justify-content: center;
align-items: center;
text-decoration: none;
color: #fff;
font-size: 32px;
border: 1px solid rgba(255,255,255,0.4);
border-right: 1px solid rgba(255,255,255,0.2);
border-bottom: 1px solid rgba(255,255,255,0.2);
/* 阴影 */
box-shadow: 0px 5px 45px rgba(0,0,0,0.1);
/* 背景模糊 */
backdrop-filter: blur(2px);
/* 动画过渡 */
transition: all 0.5s;
overflow: hidden;
}
ul li a:hover{
/* 鼠标移入元素沿Y轴上移 */
transform: translateY(-20px);
}
ul li a::before{
content: "";
position: absolute;
top: 0px;
left: 0px;
width: 50px;
height: 100%;
background-color: rgba(255,255,255,0.5);
/* 元素沿X轴45度横切,沿X轴右移150px */
transform: skewX(45deg) translateX(150px);
/* 动画过渡 */
transition: all 0.5s;
}
ul li a:hover::before{
/* 元素沿X轴45度横切,沿X轴左移150px */
transform: skewX(45deg) translateX(-150px);
}

作者:艾恩小灰灰
来源:juejin.cn/post/7091339314352619557
收起阅读 »