标签 - 转载 共找到结果 6 条

号码组成

中华人民共和国国家标准 GB 11643-1999《公民身份号码》中规定:公民身份号码是特征组合码,由十七位数字本体码和一位校验码组成。

公民身份号码是特征组合码,由十七位数字本体码和一位数字校验码组成。排列顺序从左至右依次为:六位数字地址码,八位数字出生日期码,三位数字顺序码和一位数字校验码。

  1. 地址码表示编码对象常住户口所在县(市、旗、区)的行政区划代码,按 GB/T 2260 的规定执行。

  2. 出生日期码表示编码对象出生的年、月、日,按 GB/T 7408 的规定执行。年、月、日代码之间不用分隔符。(例:某人出生日期为 1966 年 10 月 26 日,其出生日期码为 19661026。)

  3. 顺序码表示在同一地址码所标识的区域范围内,对同年、同月、同日出生的人编定的顺序号,顺序码的奇数分配给男性,偶数分配给女性。

  4. 校检码是根据前面十七位数字码,按照公式计算出来的检验码。

计算方法

  1. 将前面的身份证号码 17 位数分别乘以不同的系数,从第一位到第十七位的系数分别为:7 9 10 5 8 4 2 1 6 3 7 9 10 5 8 4 2 ;

  2. 将这 17 位数字和系数相乘的结果相加;

  3. 用加出来和除以 11,看余数是多少;

  4. 余数只可能有 0 1 2 3 4 5 6 7 8 9 10 这11个数字,其分别对应的最后一位身份证的号码为 1 0 X 9 8 7 6 5 4 3 2;

  5. 通过上面得知如果余数是 2,就会在身份证的第18位数字上出现罗马数字的 X。如果余数是 10,身份证的最后一位号码就是 2。

JavaScript代码实现:

function check(code) {
    code = code.split('');

    var factor = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2],
        parity = [1, 0, 'X', 9, 8, 7, 6, 5, 4, 3, 2],
        sum = 0,
        ai = 0,
        wi = 0;

    for (var i = 0; i < 17; i++) {
        ai = code[i];
        wi = factor[i];
        sum += ai * wi;
    }

    var last = parity[sum % 11];

    return last == code[17];
}

问题:

这种方法只能做前端的简单校验,我们java后台进行的判断方式是根据省市县出身年月算出身份证后四位,比这种只对最后一位校验要精准得多,不过不是很清楚他们的做法

阅读全文

我们知道canvas画布可以很方便的js原生支持转为图片格式并下载,但是svg矢量图形则并没有这方面原生的支持。 研究过HighChart的svg图形的图片下载机制,其实现原理大体是浏览器端收集SVG代码信息,并发送到到服务器端,由后端程序转换成图片格式后,以流的形式反射给浏览器端下载。

最近在项目中有需求将一个非HighChart的SVG地图转存为图片并下载的功能。 本希望模拟HighChart的原理实现,可是研究发现,该地图的SVG代码信息多达两万字节,然而HighChart后端制图程序却有着字节数限制,所以就不能这么处理了。

然后国外社区讨论的方法也多是前后端协同处理来完成这个功能的,这样实现会比较重, 而且部署不便。

经过一番搜寻,终于发现一个不依赖任何外部库,框架,同时仅仅通过浏览器端js便能实现的方法。 代码实现的具体来源地址已经忘记了, 这里保留代码原创作者的版权哈。

首先,我们约定SVG的上下文结构是如下的:

<div class="svg-wrap">
  <svg>...<svg>
<div>

然后,我们就可以通过如下代码来将svg图形转为图片并下载了:

var svgXml = $('.svg-wrap').html();

var image = new Image();
image.src = 'data:image/svg+xml;base64,' + window.btoa(unescape(encodeURIComponent(svgXml))); //给图片对象写入base64编码的svg流

var canvas = document.createElement('canvas');  //准备空画布
canvas.width = $('.svg-wrap svg').width();
canvas.height = $('.svg-wrap svg').height();

var context = canvas.getContext('2d');  //取得画布的2d绘图上下文
context.drawImage(image, 0, 0);

var a = document.createElement('a');
a.href = canvas.toDataURL('image/png');  //将画布内的信息导出为png图片数据
a.download = "MapByMathArtSys";  //设定下载名称
a.click(); //点击触发下载

阅读全文

Promise in js

回调函数真正的问题在于他剥夺了我们使用 return 和 throw 这些关键字的能力。而 Promise 很好地解决了这一切。

2015 年 6 月,ECMAScript 6 的正式版 终于发布了。

ECMAScript 是 JavaScript 语言的国际标准,JavaScript 是 ECMAScript 的实现。ES6 的目标,是使得 JavaScript 语言可以用来编写大型的复杂的应用程序,成为企业级开发语言。

概念

ES6 原生提供了 Promise 对象。

所谓 Promise,就是一个对象,用来传递异步操作的消息。它代表了某个未来才会知道结果的事件(通常是一个异步操作),并且这个事件提供统一的 API,可供进一步处理。

Promise 对象有以下两个特点。

(1)对象的状态不受外界影响。Promise 对象代表一个异步操作,有三种状态:Pending(进行中)、Resolved(已完成,又称 Fulfilled)和 Rejected(已失败)。只有异步操作的结果,可以决定当前是哪一种状态,任何其他操作都无法改变这个状态。这也是 Promise 这个名字的由来,它的英语意思就是「承诺」,表示其他手段无法改变。

(2)一旦状态改变,就不会再变,任何时候都可以得到这个结果。Promise 对象的状态改变,只有两种可能:从 Pending 变为 Resolved 和从 Pending 变为 Rejected。只要这两种情况发生,状态就凝固了,不会再变了,会一直保持这个结果。就算改变已经发生了,你再对 Promise 对象添加回调函数,也会立即得到这个结果。这与事件(Event)完全不同,事件的特点是,如果你错过了它,再去监听,是得不到结果的。

有了 Promise 对象,就可以将异步操作以同步操作的流程表达出来,避免了层层嵌套的回调函数。此外,Promise 对象提供统一的接口,使得控制异步操作更加容易。

Promise 也有一些缺点。首先,无法取消 Promise,一旦新建它就会立即执行,无法中途取消。其次,如果不设置回调函数,Promise 内部抛出的错误,不会反应到外部。第三,当处于 Pending 状态时,无法得知目前进展到哪一个阶段(刚刚开始还是即将完成)。

var promise = new Promise(function(resolve, reject) {
 if (/* 异步操作成功 */){
 resolve(value);
 } else {
 reject(error);
 }
});

promise.then(function(value) {
 // success
}, function(value) {
 // failure
});

Promise 构造函数接受一个函数作为参数,该函数的两个参数分别是 resolve 方法和 reject 方法。

如果异步操作成功,则用 resolve 方法将 Promise 对象的状态,从「未完成」变为「成功」(即从 pending 变为 resolved);

如果异步操作失败,则用 reject 方法将 Promise 对象的状态,从「未完成」变为「失败」(即从 pending 变为 rejected)。

基本的 api

  1. Promise.resolve()
  2. Promise.reject()
  3. Promise.prototype.then()
  4. Promise.prototype.catch()
  5. Promise.all() // 所有的完成

     var p = Promise.all([p1,p2,p3]);
  6. Promise.race() // 竞速,完成一个即可

进阶

promises 的奇妙在于给予我们以前的 return 与 throw,每个 Promise 都会提供一个 then() 函数,和一个 catch(),实际上是 then(null, ...) 函数,

    somePromise().then(functoin(){
        // do something
    });

我们可以做三件事,

1. return 另一个 promise
2. return 一个同步的值 (或者 undefined)
3. throw 一个同步异常 ` throw new Eror('');`

1. 封装同步与异步代码

```
new Promise(function (resolve, reject) {
 resolve(someValue);
 });
```
写成

```
Promise.resolve(someValue);
```

2. 捕获同步异常

 new Promise(function (resolve, reject) {
 throw new Error('悲剧了,又出 bug 了');
 }).catch(function(err){
 console.log(err);
 });

如果是同步代码,可以写成

    Promise.reject(new Error("什么鬼"));

3. 多个异常捕获,更加精准的捕获

somePromise.then(function() {
 return a.b.c.d();
}).catch(TypeError, function(e) {
 //If a is defined, will end up here because
 //it is a type error to reference property of undefined
}).catch(ReferenceError, function(e) {
 //Will end up here if a wasn't defined at all
}).catch(function(e) {
 //Generic catch-the rest, error wasn't TypeError nor
 //ReferenceError
});

4. 获取两个 Promise 的返回值

1. .then 方式顺序调用
2. 设定更高层的作用域
3. spread

5. finally

任何情况下都会执行的,一般写在 catch 之后

6. bind

somethingAsync().bind({})
.spread(function (aValue, bValue) {
 this.aValue = aValue;
 this.bValue = bValue;
 return somethingElseAsync(aValue, bValue);
})
.then(function (cValue) {
     return this.aValue + this.bValue + cValue;
});

或者 你也可以这样

var scope = {};
somethingAsync()
.spread(function (aValue, bValue) {
 scope.aValue = aValue;
 scope.bValue = bValue;
 return somethingElseAsync(aValue, bValue);
})
.then(function (cValue) {
 return scope.aValue + scope.bValue + cValue;
});

然而,这有非常多的区别,

  1. 你必须先声明,有浪费资源和内存泄露的风险
  2. 不能用于放在一个表达式的上下文中
  3. 效率更低

7. all。非常用于于处理一个动态大小均匀的 Promise 列表

8. join。非常适用于处理多个分离的 Promise

```
var join = Promise.join;
join(getPictures(), getComments(), getTweets(),
 function(pictures, comments, tweets) {
 console.log("in total: " + pictures.length + comments.length + tweets.length);
});
```

9. props。处理一个 promise 的 map 集合。只有有一个失败,所有的执行都结束

```
Promise.props({
 pictures: getPictures(),
 comments: getComments(),
 tweets: getTweets()
}).then(function(result) {
 console.log(result.tweets, result.pictures, result.comments);
});
```

10. any 、some、race

```
Promise.some([
 ping("ns1.example.com"),
 ping("ns2.example.com"),
 ping("ns3.example.com"),
 ping("ns4.example.com")
], 2).spread(function(first, second) {
 console.log(first, second);
}).catch(AggregateError, function(err) {

err.forEach(function(e) {
console.error(e.stack);
});
});;

```
有可能,失败的 promise 比较多,导致,Promsie 永远不会 fulfilled

11. .map(Function mapper [, Object options])

用于处理一个数组,或者 promise 数组,

Option: concurrency 并发现

    map(..., {concurrency: 1});

以下为不限制并发数量,读书文件信息

var Promise = require("bluebird");
var join = Promise.join;
var fs = Promise.promisifyAll(require("fs"));
var concurrency = parseFloat(process.argv[2] || "Infinity");

var fileNames = ["file1.json", "file2.json"];
Promise.map(fileNames, function(fileName) {
 return fs.readFileAsync(fileName)
 .then(JSON.parse)
 .catch(SyntaxError, function(e) {
 e.fileName = fileName;
 throw e;
 })
}, {concurrency: concurrency}).then(function(parsedJSONs) {
 console.log(parsedJSONs);
}).catch(SyntaxError, function(e) {
 console.log("Invalid JSON in file " + e.fileName + ": " + e.message);
});

结果

$ sync && echo 3 > /proc/sys/vm/drop_caches
$ node test.js 1
reading files 35ms
$ sync && echo 3 > /proc/sys/vm/drop_caches
$ node test.js Infinity
reading files: 9ms

11. .reduce(Function reducer [, dynamic initialValue]) -> Promise

Promise.reduce(["file1.txt", "file2.txt", "file3.txt"], function(total, fileName) {
 return fs.readFileAsync(fileName, "utf8").then(function(contents) {
 return total + parseInt(contents, 10);
 });
}, 0).then(function(total) {
 //Total is 30
});

12. Time

  1. .delay(int ms) -> Promise
  2. .timeout(int ms [, String message]) -> Promise

Promise 的实现

  1. q
  2. bluebird
  3. co
  4. when

ASYNC

async 函数与 Promise、Generator 函数一样,是用来取代回调函数、解决异步操作的一种方法。它本质上是 Generator 函数的语法糖。async 函数并不属于 ES6,而是被列入了 ES7。

参考文献(说是抄也可以的):

阮一峰的ES6 教程
关于promises,你理解了多少?
Bluebird 的官方文档

阅读全文


作为一名年轻的程序员,我渴望在我的职业生涯中成长,我想要知道为了成为一名高级程序员,我们的目标要怎么设定。我询问过我的经理和导师,并惊讶地发现,要成为高级程序员,不仅仅是依靠学习和掌握技术(当然你需要不断学习,要保持技术领先)。除了技术之外,成为优秀程序员需要关注团队合作、沟通和注意细节。几乎没有一点行业经验的新手也可以根据技术判断出什么样的程序员是优秀的,但是需要一点技术之外的东西才能让你从优秀程序员中脱颖而出,成为伟大的程序员。

好程序员测试她的代码来确保它能正常工作。

伟大的程序员测试她的代码来确保它不会不工作。

这可不是文字游戏 —— 正向和逆向测试之间有明显区别,而两者在软件工程中都是必不可少的。每个人在写好代码之后都测试他们的代码来确保它能按照他们的预期工作。但是,这只是第一步。通过不同的用例或用户行为,充分思考出错的潜在风险并防御性地编程来避免一些问题,能有助于让你的应用有很长的“保质期”。

好程序员积极协助设置代码约定。

伟大的程序员遵守代码约定,即使它们与她自己的习惯不符。

遵守代码约定是一件大事。这么做的目的是让开发团队的思想统一,而约定对实现理想的思想统一是至关重要的。它需要成熟的心态和卓越的承诺,为了团队更好,妥协你做事情的方式,从而产生更多的凝聚力和一致的工作。团队中的最强的人会理解团队合作和达成共识的重要性。

好程序员写简洁的代码。

伟大的程序员写简洁的代码,最后再整理一遍并为它撰写文档。

如果你满足于让代码“足够好”,那么它实际上还不够好。要以高标准来对待你的工作,要记住当下一次你再阅读你写的代码的时候,由于时过境迁,你不会马上有相同的理解,而其他人检阅代码时,他们可能需要你的指点,你得告诉他们为什么你当时用这个方法实现。考虑以最好的方式来组织你的代码,并在你写了与它有关的其他组件之后再重新审视它。这些都是关于精益求精,重构使它优雅而高效。同时,为你的代码写文档。这非常重要。你团队的标准和代码约定应当强制使用代码注释。要把你的想法准确传达给使用你的代码的其他程序员,通过一个 readme 文件甚至一个 wiki 来整理清晰的文档,告诉使用者这些代码能做什么以及如何使用(给出例子)。

好程序员能独立解决问题。

伟大的程序员认识到她所在团队的专业知识的价值并在需要的时候充分挖掘团队的力量。

虽然对于工程师来说独立工作的能力是重要的,但依赖团队也是很好理解的,每个人都需要在项目的某个点上接受指导,甚至需要一点点帮助。一名初级工程师可能在日常任务上需要更多手把手的指导,而一个更高级的工程师可能需要对岗位要求的澄清或者在性能优化方面的指导。需要指导没什么不好意思的。最重要的一点是别害怕问问题,而一旦你的问题解决了,你可以继续前进直到遇到下一个障碍。成为一个独行侠没什么好处,那样你会为迟迟无法成功而感到沮丧,而那些驱动整个项目的人也会为项目迟迟没有进展而感到沮丧。一个成熟的、有自信的程序员知道她的能力和弱点,不害怕向团队成员求助,必要时借助团队力量而不是试图成为个人英雄。

好程序员学习效率工具并将它们有效地用于简化她的工作流。

伟大的程序员自己定制工作来提高效率并改进她的工作环境和工作流。

用你在项目中使用到的一切技术,花点时间改进流程。它也能对前面提到的一些点有帮助,比如写一个 linter(代码提示工具)来检查你的代码,看是否严谨和符合约定,或者写测试工具来自动化测试你的代码流程。

好程序员评审她团队成员的代码来保证质量。

伟大的程序员在代码评审中给出详细的,合理的,建设性的评论来帮助与她一起共事的程序员,让他们在知识和专业领域上有所成长。

理解沟通的重要性并以高标准严格要求。优雅地推动你的同事不断进步,为他们的职业生涯清除障碍,这将会让你成为一名好的领导者。这让我们回归合作的本质 —— 为了更大的群体利益,而且这也是在知识上的投资,能帮助你的团队成功。

这些都是随着时间的推移而建立的技能和习惯。我坚信“我们从一开始就要相信自己能行”(凡事都得有开始),但是我也相信“我们没法掩盖沮丧”。成功没有捷径。真正的技巧和专业知识是经过长时间的开发实践积累的。都说做一件事需要花费 10000 小时,才能成为行家。谁都可以选择掌握深度或者掌握广度,广度提升我们对大方向的理解而深度则提升我们的专业能力 —— 其实,这两者都不可或缺。热爱你的职业生涯旅途并学会欣赏你自己成长的过程。但不管你是一名有十年经验的老手还是才入行一个月的菜鸟,不要满足于足够好。在你的团队成为伟大的程序员并领导其他人,照顾好他们。

英文原文:https://blog.prototypr.io/what-makes-a-good-developer-great-87c6ed3a1d93?swoff=true#.uf4f9fi7a

阅读全文

原文:http://www.zcfy.cc/article/2127

“征服 JavaScript 面试”是我写的一系列文章,来帮助面试者准备他们在面试 JavaScript 中、高级职位中将可能会遇到的一些问题。这些问题我自己在面试中也经常会问。

在我面试时问出的一系列问题里,闭包通常是我问的第一个或最后一个问题。坦白地说,如果你连闭包也弄不明白,你是不会在 JavaScript 的道路上走多远的。

你别东张西望,说的就是你。你真的理解如何构建一个严谨的 JavaScript 应用?你真的理解代码背后发生的事情或者说一个应用程序是如何工作的?我表示怀疑。如果连个闭包问题都搞不清的话,真是有点够呛。

你不仅仅应该了解闭包的机制,更应该了解闭包为什么很重要,以及能够很容易地回答出闭包的几种可能的应用场景。

闭包在 JavaScript 中常用来实现对象数据的私有,在事件处理和回调函数中也常常会用到它,此外还有偏函数应用(partial applications)和柯里化(currying),以及其他函数式编程模式。

我不在乎面试者是否知道“closure”这个单词或者它的专业定义。我只想弄清他们是否理解基本原理。如果他们没有,那么通常意味着这些面试者在构建实际 JavaScript 应用方面并没有很多经验。

如果你不能回答这个问题,你只是个初级开发者。不管你实际上已经干这个多久了。

为了快速理解下面的内容:你想一下能否举出两个闭包的通用场景?

什么是闭包?

简言之,闭包是由函数引用其周边状态(词法环境)绑在一起形成的(封装)组合结构。在 JavaScript 中,闭包在每个函数被创建时形成。

这是基本原理,但为什么我们关心这些?实际上,由于闭包与它的词法环境绑在一起,因此闭包让我们能够从一个函数内部访问其外部函数的作用域

要使用闭包,只需要简单地将一个函数定义在另一个函数内部,并将它暴露出来。要暴露一个函数,可以将它返回或者传给其他函数。

内部函数将能够访问到外部函数作用域中的变量,即使外部函数已经执行完毕。

闭包使用的例子

闭包的用途之一是实现对象的私有数据。数据私有是让我们能够面向接口编程而不是面向实现编程的基础。而面向接口编程是一个重要的概念,有助于我们创建更加健壮的软件,因为实现细节比接口约定相对来说更加容易被改变。

“面向接口编程,别面向实现编程。” 设计模式:可复用面向对象软件的要素

在 JavaScript 中,闭包是用来实现数据私有的原生机制。当你使用闭包来实现数据私有时,被封装的变量只能在闭包容器函数作用域中使用。你无法绕过对象被授权的方法在外部访问这些数据。在 JavaScript 中,任何定义在闭包作用域下的公开方法才可以访问这些数据。例如:

const getSecret = (secret) => {
  return {
    get: () => secret
  };
};

test("Closure for object privacy.", assert => {
  const msg = ".get() should have access to the closure.";
  const expected = 1;
  const obj = getSecret(1);

  const actual = obj.get();

  try {
    assert.ok(secret, "This throws an error.");
  } catch (e) {
    assert.ok(true, `The secret var is only available
      to privileged methods.`);
  }

  assert.equal(actual, expected, msg);
  assert.end();
});

在上面的例子里,get() 方法定义在 getSecret() 作用域下,这让它可以访问任何 getSecret() 中的变量,于是它就是一个被授权的方法。在这个例子里,它可以访问参数 secret

对象不是唯一的产生私有数据的方式。闭包还可以被用来创建有状态的函数,这些函数的执行过程可能由它们自身的内部状态所决定。例如:

const secret = (msg) => () => msg;
// Secret - creates closures with secret messages.
// https://gist.github.com/ericelliott/f6a87bc41de31562d0f9
// https://jsbin.com/hitusu/edit?html,js,output

// secret(msg: String) => getSecret() => msg: String
const secret = (msg) => () => msg;

test("secret", assert => {
  const msg = "secret() should return a function that returns the passed secret.";

  const theSecret = "Closures are easy.";
  const mySecret = secret(theSecret);

  const actual = mySecret();
  const expected = theSecret;

  assert.equal(actual, expected, msg);
  assert.end();
});

在函数式编程中,闭包经常用于偏函数应用和柯里化。为了说明这个,我们先定义一些概念:

函数应用:一个过程,指将参数传给一个函数,并获得它的返回值。

偏函数应用:一个过程,它传给某个函数其中一部分参数,然后返回一个新的函数,该函数等待接受后续参数。换句话说,偏函数应用是一个函数,它接受另一个函数为参数,这个作为参数的函数本身接受多个参数,它返回一个函数,这个函数与它的参数函数相比,接受更少的参数。偏函数应用提前赋予一部分参数,而返回的函数则等待调用时传入剩余的参数。

偏函数应用通过闭包作用域来提前赋予参数。你可以实现一个通用的函数来赋予指定的函数部分参数,它看起来如下:

partialApply(targetFunction: Function, ...fixedArgs: Any[]) =>
  functionWithFewerParams(...remainingArgs: Any[])

如果你要更进一步理解上面的形式,你可以看这里

partialApply 接受一个多参数的函数,以及一串我们想要提前赋给这个函数的参数,它返回一个新的函数,这个函数将接受剩余的参数。

下面给一个例子来说明,假设你有一个函数,求两个数的和:

const add = (a, b) => a + b;

现在你想要得到一个函数,它能够对任何传给它的参数都加 10,我们可以将它命名为 add10()add10(5) 的结果应该是 15。我们的 partialApply() 函数可以做到这个:

const add10 = partialApply(add, 10);
add10(5);

在这个例子里,参数 10 通过闭包作用域被提前赋予 add(),从而让我们获得 add10()

现在让我们看一下如何实现 partialApply()

// Generic Partial Application Function
// https://jsbin.com/biyupu/edit?html,js,output
// https://gist.github.com/ericelliott/f0a8fd662111ea2f569e

// partialApply(targetFunction: Function, ...fixedArgs: Any[]) =>
//   functionWithFewerParams(...remainingArgs: Any[])
const partialApply = (fn, ...fixedArgs) => {
  return function (...remainingArgs) {
    return fn.apply(this, fixedArgs.concat(remainingArgs));
  };
};


test("add10", assert => {
  const msg = "partialApply() should partially apply functions"

  const add = (a, b) => a + b;

  const add10 = partialApply(add, 10);


  const actual = add10(5);
  const expected = 15;

  assert.equal(actual, expected, msg);
});

如你所见,它只是简单地返回一个函数,这个函数通过闭包访问了传给 partialApply() 函数的 fixedArgs 参数。

轮到你来试试了

你用闭包来做什么?如果你有最喜欢的应用场景,举一些例子,在评论中告诉我。

英文原文:https://medium.com/javascript-scene/master-the-javascript-interview-what-is-a-closure-b2f0d2152b36#.yuiywtkcn

阅读全文