获取拼音首拼应该也是蛮常见的需求吧，如果对于小一点的项目来说，为了达到这个目的而去引用一个完整的拼音库好像有点得不偿失，因为它们的体积往往都比较大。于是经过原作者同意，我就基于pinyinjs写了一个专门获取汉字首拼的工具库 - pyfl。
具体的使用场景比如说。微信的通讯录，手机的通讯录之类的。这里的分组可以由服务端做，也可以由前端来。
不管你是否是前端还是后端都可以使用pyfl。如果你是node，你可以通过require("pyfl").default;来使用。以下是一般的前端项目的用法。
import pyfl from 'pyfl';
pyfl('喵'); // M
pyfl('好笑吗跟傻子一样整天就知道哈哈哈哈哈哈哈')); // HXMGSZYYZTJZDHHHHHHH
pyfl('罤夶繙着洗'); // TBFZX
pyfl('Pure'); // Pure
pyfl('Made by ❤'); // Made by ❤
pyfl会把支持的汉字转换成大写的拼音输出出来。如果是英文或者奇怪的文字比如阿拉伯语的话会原样输出出来。
简历传送门：casperchen@tencent.com
我是刚学Node.js，现在学那个node.js链接mysql数据库，然后有require(‘mysql’),然后出现的问题就是在node环境下没问题，但只要我想用webpack打包的时候就会出现can’t resolve module ‘fs’,请问这是什么问题？
测试 测试测试
关於前端跨全平台框架的建议，以及跟node的搭配
微软：Xamarin c# 谷歌：dart flutter dart language 阿里：weex js 脸书：React Native js
其他等等五花八门
不晓得各位会选哪个，优缺点？有好的建议吗？谢谢~
最近做vue项目时遇到很多在子组件里边缓存了表单数据的情况，不想重新写一遍恢复默认值，请问大家有没有好的解决方案
想要请教一下各位，使用node.js(egg.js)，会搭配哪一个「权限管理框架」一起使用？(主要在管理哪些功能、或字段的权限，用户可以/不可以察看、修改等等)
我还真不知道实务上要用哪个，若是使用RBAC (Role Base Access Control)，这个我会，但是太麻烦了！
一个记得发动机反间谍法京东方活动经费活动经费较好的反间谍法
可是顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶顶
公司今年业务发展有点快，团队扩张，需要扩充前端、后端开发人员。 （集团旗下的教育板块和金融板块两个子公司进行人员扩张）
公司业务主要是 K12 教育相关的项目，主要涉及少年宫、游学、智慧城市（教育方向等） 金融业务那边，已经处于盈利阶段，也需要进行业务（技术平台的）开发。
周末双休。 工作地点：广州白云区三元里大道北（公司自有停车场，免费停车，整栋六层办公楼） 招人目标，2年+，薪酬范围 13 - 18 （金融板块的话那边的职位要求越高越好，薪资范围25上限），此价格为平均市场价。
建议附上个人技术 blog or github 项目
简历发送地址：atob('==QbvNmLn52copHZnRVQpVHapFnblh2c'.split('').reverse().join('')).replace('AT', '@')附上拉钩： https://www.lagou.com/gongsi/j113578.html。 v2： https://www.v2ex.com/t/539545
用来捕获流媒体 ts文件
eggjs会怎么处理呢？会排队吗？还是当做没看见
播放内容还是html5 video支持的，仅换个样式。
报错信息如下
用浏览器访问接口，得到的数据如下：
贴上代码：
var https = require('https') // Node.js提供了http模块，用于搭建HTTP服务端和客户端
function sendRequest(path) {
return new Promise(function (resolve, reject) {
https.get({
path: path,
hostname: 'cnodejs.org',
headers: {
Accept: 'Accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8'
}
}, function (res) { //发送get请求
var result = null
res.on('data', function (data) {
result = '' + data
})
res.on('end', function () {
resolve(JSON.parse(result, (key, value) => {
if (['content', 'title'].indexOf(key) > -1) {
return ''
} else {
return value
}
}))
})
}).on('error', function (e) {
reject(e)
})
})
}
sendRequest('/api/v1/topics').then(res => {
console.log(res.data.length)
}).catch(e => {
console.log(e)
})
请问有没有什么办法可以解决这个问题？
有人会加个用户密码登陆吗，cnode的Android客户端纯原生代码，需要加个用户密码登陆
想问一下大神们，koa2加载less文件的中间件有哪些呢？ 不知道这问题会不会很低级，但是能用的我google不到，koa-less这些被废弃了~
如果有一个单向链表，链表当中有可能出现＂环＂，就像下图这样，如何判断这个链表是有环链表？
方案一：暴力法
从头节点，依次遍历单链表的每一个节点，每到一个新的节点就头节点重新遍历之前的所有的节点，对比此时的节点，如果相同，证明该节点遍历过两次，以此说明链表是有环的
Node p = head.next
while(p.next!==null){
Node c = head
while(c!==p){
c=c.next
}
if(c.next!==p.next){
return true
}
p = p.next
}
return false;
此方案时间复杂度为Ｏ（ｎ＾２），空间复杂度为O(1)
第二种方案：用hashMap缓存遍历的过的节点
还是头节点进行遍历，每一次遍历新的节点时，对比存储到hashMap集合是否有相同的节点，有，证明有环，无，存储到集合中
伪代码：
Node p = head
HashMap hm = new HashMap()<Node,Node>
while(p!=null){
if(hm.get(p)){
return true
}
hm.put(p,p)
p =p.next
}
第三种方案：双指针遍历
首先创建两个指针1和2，同时指向这个链表的头节点。然后开始一个大循环，在循环体中，让指针1每次向下移动一个节点，让指针2每次向下移动两个节点，然后比较两个指针指向的节点是否相同。如果相同，则判断出链表有环，如果不同，则继续下一次循环
伪代码：
Node p = head
Node q = head.next
while(p!==q){
if(p.next==null) return false
p =p.next
if(q.next==null) return false
if(q.next.next==null) return false
q = q.next.next
}
return true
此方案的时间复杂度为O(n),空间复杂度为O(1)
该文章阅读需要5分钟,更多文章请点击本人博客halu886
在API的暴露上，Promise比原生的事件侦听和触发更加优雅，但是原始的方式更加灵活，但是在一些经典的场景下，封装API并不高，还是值得一做。
Promise的秘诀在于队列的操作，当存在需要和服务器进行多次指令操作时，可以用deferred模式解决问题。
当有一组纯异步的API，操作如下
obj.api1(function(value1){
obj.api2(function(value2){
obj.api3(function(value3){
obj.api4(function(value4){
callback(value4)
}
}
}
})
当每个请求都依赖于上一个请求时，当业务一复杂，嵌套则非常不友好，也被称为“Pyramid of Doom”。也被译为回调金字塔。
如果尝试用普通函数进行展开
var handle1 = function (value1){
obj.api2(value1,handler2);
}
var handle2 = function (value2){
obj.api3(value2,handler3);
}
var handle3 = function (value3){
obj.api4(value3,handler4);
}
var handle4 = function (value4){
callback(value4);
}
obj.api1(handler1);
如果使用事件进行展开
var emitter = new event.Emitter();
emitter.on("step1",function(){
obj.api1(function(value1){
emitter.emit("step2",value1);
})
});
emitter.on("step2",function(value1){
obj.api2(value1,function(value2){
emitter.emit("step3",value2);
})
});
emitter.on("step3",function(value2){
obj.api3(value2,function(value3){
emitter.emit("step4",value3);
})
});
emitter.on("step4",function(value3){
obj.api4(value3,function(value4){
callback(value4);
})
});
emitter.emit("step1");
通过事件模式进行展开越来越糟糕了，代码行数变多了。
理想的编程方式应该时前一个调用完后发起下一个调用，也就是所谓的链式调用。
promise()
.then(obj.api1)
.then(obj.api2)
.then(obj.api3)
.then(obj.api4)
.then(function(value4){
// Do something with value4
},function(error){
// Handle any error from step1 through step3
})
.done();
尝试改造一下，调用如下
var Deferred = function(){
this.promise = new Promise();
}
Deferred.prototype.resolve = function(obj){
var promise= this.promise;
var handler;
while((handler = promise.queue.shift())){
if(handler && handler.fulfilled){
var ret = handler.fulfilled(obj);
if(ret && ret.isPromise){
ret.queue = promise.queue;
this.promise = ret;
return;
}
}
}
}
// 失败态
Deferred.prototype.reject = function(err){
var promise = this.promise;
var handler;
while((handler = promise.queue.shift())){
if(handler && handler.error){
var ret = handler.error(err);
if(ret && ret.isPromise){
ret.queue = promise.queue;
this.promise = ret;
return;
}
}
}
};
// 生成回调函数
Deferred.prototype.callback = function(){
var that = this;
return function(err,file){
if(err){
return that.reject(err);
}
that.resolve(file);
};
};
var Promise = function(){
// 队列用于存储待执行的回调函数
this.queue = [];
this.isPromise = true;
}
Promise.prototype.then = function(fulfilledHandler,errorHandler,progressHandler){
var handler = {};
if(typeof fulfilledHandler === 'function'){
handler.fulfilled = fulfilledHandler;
}
if(typeof errorHander === 'function'){
handler.error = errorHandler;
}
this.queue.push(handler);
return this;
}
这里我们以读取两次文件为例，第二个文件的读取依赖于第一个文件的内容。
var readFile1 = function(file,encoding){
var deferred = new Deferred();
fs.readFile(file,encoding,deferred.callback());
return deferred.promise;
}
var readFile2 = function (file,encoding){
var deferred = new Deferred();
fs.readFile(file,encoding,deferred.callback());
return deferred.promise;
}
readFile1('file1.txt','utf8').then(function(file1){
return readFile2(file1.trim().'utf8');
}).then(function(file2){
console.log(file2);
})
让Promise支持链式，主要有两个步骤：
这里提供一个方法可以实现 API批量 Promise化
// smooth(fs.readFile);
var smooth = function(method){
return function(){
var deferred = new Deferred();
var args = Array.prototype.slice.call(arguments,1);
args.push(deferred.callback());
method.apply(null,args);
return deferred.promise;
};
};
于是前两次文件的构造如下
var readFile1 = function(file,encoding){
var deferred = new Deferred();
fs.readFile(file,encoding,deferred.callback());
return deferred.promise;
}
var readFile2 = function(file,encoding){
var deferred = new Deferred();
fs.readFile(file,encoding,deferred.callback());
return deferred.promise;
}
可以简化为
var readFile = smooth(fs.readFile);
实现同样的效果时，代码量将会锐减到到
var readFile = smooth(fs.readFile);
readFile('file1.txt','utf8').then(function(file1){
return readFile(file1.trim(),'utf8');
}).then(function(file2){
console.log(file2);
})
以上知识点均来自<<深入浅出Node.js>>，更多细节建议阅读书籍:-)
