JavaScript

基础写法

Hello World

console.log('Hello, world!');

常用的库

relationship

var relationship = require("relationship.js");
var options = {text:'儿子的爸爸的妈妈',sex:1};
console.log('relationship: ', relationship(options));

pinyin

var pinyin = require("pinyin");
console.log('pinyin: ', pinyin("中心"));

nodejieba

Error: Cannot find module './build/Release/nodejieba.node'
修改 ".\node_modules\nodejieba\index.js"
var nodejieba = require("./build/Release/nodejieba.node");  ->   var nodejieba = require(".");

js 模块导出

基本方式

// 导出
function sum(a, b) {
    return a+b;
}
module.exports = sum
// 导入
//const lmd5 = require('./sum.js');
//console.log(sum(1, 2))

匿名方式

// 导出
module.exports = {
  myAirplane:"CloudJet",
  displayAirplane:function(){
    return this.myAirplane;
  }
};
// 导入
//const Airplane = require('./lmd5.js');
//console.log(Airplane.myAirplane);

导出闭包中的函数

参考 sohu3.js

常用加解密库

对称加密算法主要有AES、DES、3DES，非对称加密算法主要有RSA、DSA、RCC

AES

AES 参数的意义

1. key length（密钥位数，密码长度）
   AES128，AES192，AES256（128 位、192 位或 256 位）
   128位对应的是16个字节，所以部分平台库上，会使用16个字符或者长度为16的字符串来做密码。
2. key （密钥，密码）
   key指的就是密码了，AES128就是128位的，如果位数不够，某些库可能会自动填充到128。
3. IV （初始向量）
   IV称为初始向量，不同的IV加密后的字符串是不同的，加密和解密需要相同的IV。
4. mode （加密模式）
   AES分为几种模式，比如ECB，CBC，CFB等等，这些模式除了ECB由于没有使用IV而不太安全，其他模式差别并没有太明显。
5. padding （填充方式）
   对于加密解密两端需要使用同一的PADDING模式，大部分PADDING模式为PKCS5, PKCS7, AnsiX923、Iso10126、ZeroPadding。

CryptoJS

github
// npm install crypto-js -> crypto-js-4.1.1.tgz
// https://code.google.com/archive/p/crypto-js/downloads -> CryptoJS v3.1.2.zip

var CryptoJS = require("crypto-js");

//使用CryptoJS实现AES加密方法
function aa(word, key) {
    var key = CryptoJS.enc.Utf8.parse(key)
      , iv = CryptoJS.enc.Utf8.parse("0102030405060708")
      , srcs = CryptoJS.enc.Utf8.parse(word)
      , f = CryptoJS.AES.encrypt(srcs, key, {
        iv: iv,
        mode: CryptoJS.mode.CBC,
        padding: CryptoJS.pad.Pkcs7
    });
    return f.toString()
}

//使用CryptoJS实现AES加密方法 mode === ECB 时, 不需要 iv
function bb(word, key) {
    var key = CryptoJS.enc.Utf8.parse(key)
      , srcs = CryptoJS.enc.Utf8.parse(word)
      , f = CryptoJS.AES.encrypt(srcs, key, {
        mode: CryptoJS.mode.ECB,
        padding: CryptoJS.pad.Pkcs7
    });
    return f.toString()
}

var word = '{"ids":"[1936526131]","level":"standard","encodeType":"aac","csrf_token":""}'
var key = "0CoJUm6Qyw8W8jud"

console.log('CryptoJS AES.encrypt CBC:', aa(word, key))
console.log('CryptoJS AES.encrypt ECB:', bb(word, key))
// CryptoJS AES.encrypt CBC: dNwcOgdzFvO68n6gpypa24AfvOFm7dj5j1dLPEkQHLX/cUlb+Q9sZ7hP1k4hnQqWGN0OHwXPxidkXQzd14/gsrkzk/AgUSl73E0Byn2leFE=
// CryptoJS AES.encrypt ECB: 4+FddjjhpxBNf7qYlOV0TKfNJKW+URhxizlFOtkTcOr00pKAQ80VpKvm9ApPQmSPWgrCyQo+yPTQGqQBzvVcebN3wyFVb3stHanbRSK/Yd8=

//使用CryptoJS实现AES解密方法
function cc(srcs, key) {
    var key = CryptoJS.enc.Utf8.parse(key)
      , iv = CryptoJS.enc.Utf8.parse("0102030405060708")
      , f = CryptoJS.AES.decrypt(srcs, key, {
        iv: iv,
        mode: CryptoJS.mode.CBC,
        padding: CryptoJS.pad.Pkcs7
    });
    return f.toString(CryptoJS.enc.Utf8)
}

var srcs = "dNwcOgdzFvO68n6gpypa24AfvOFm7dj5j1dLPEkQHLX/cUlb+Q9sZ7hP1k4hnQqWGN0OHwXPxidkXQzd14/gsrkzk/AgUSl73E0Byn2leFE="
var key = "0CoJUm6Qyw8W8jud"

console.log('CryptoJS AES.decrypt CBC:', cc(srcs, key))
// CryptoJS AES.decrypt CBC: {"ids":"[1936526131]","level":"standard","encodeType":"aac","csrf_token":""}

//使用CryptoJS实现MD5加密

var str = '123456'

const md5 = str => CryptoJS.MD5(str).toString()//.toUpperCase()
console.log('CryptoJS md5 32位: ', md5(str))
console.log('CryptoJS md5 32位: ', md5(str).toUpperCase())
console.log('CryptoJS md5 16位: ', md5(str).substring(8,24).toUpperCase())
console.log('CryptoJS md5 16位: ', md5(str).substring(8,24))

const sha1 = str => CryptoJS.SHA1(str).toString()
console.log('CryptoJS sha1 40位: ', sha1(str))

const sha256 = str => CryptoJS.SHA256(str).toString()
console.log('CryptoJS sha256 64位: ', sha256(str))

const sha512 = str => CryptoJS.SHA512(str).toString()
console.log('CryptoJS sha512 128位: ', sha512(str))

//使用CryptoJS实现Base64编码、解码

var string = 'Hello World!';
var base64_string = "SGVsbG8gV29ybGQh"

// base64 编码  // 输出: "SGVsbG8gV29ybGQh"
var wordArray = CryptoJS.enc.Utf8.parse(string);
var base64 = CryptoJS.enc.Base64.stringify(wordArray);
console.log('Base64 encode:', base64);

// base64 解码  // 输出: "Hello World!"
var parsedWordArray = CryptoJS.enc.Base64.parse(base64_string);
var parsedStr = parsedWordArray.toString(CryptoJS.enc.Utf8);
console.log("Base64 decode:",parsedStr);

JSEncrypt

github
// npm install jsencrypt -> jsencrypt-3.2.1.tgz

navigator = this;
window = this;

var JSEncrypt = require("jsencrypt").JSEncrypt;

// JSEncrypt版本
console.log('JSEncrypt.version: ', JSEncrypt.version)

// RSA加密
function fun_rsa_encrypt(password, publicKey) {
    var encrypt = new JSEncrypt();
    encrypt.setPublicKey(publicKey);
    encrypt_password = encrypt.encrypt(password);
    return encrypt_password
}

// RSA解密
function fun_rsa_decrypt(encrypt_msg, privateKey) {
    var decrypt = new JSEncrypt();
    decrypt.setPrivateKey(privateKey);
    decrypt_msg = decrypt.decrypt(encrypt_msg);
    return decrypt_msg
}

// RSA分段解密 当要解密的内容过长时，要进行分段解密
//const decryptLong = (content:string) => {
//  const enc = new JSEncrypt({});
//  enc.setPrivateKey(LICENSE_KEY);  // 私钥
//  let k = enc.getKey();
//  let maxLength = 128;
//  try {
//    let hexStr = b64tohex(content);
//    if (hexStr.length > maxLength * 2) {
//      let hexStrArr = hexStr.match(/.{1,256}/g);  // 128位解密。取256位
//      const ct = hexStrArr.map(entry => k.decrypt(entry)).join('');
//      return ct;
//    } else {
//      return k.decrypt(hexStr);
//    }
//  } catch (ex) {
//    return false;
//  }
//};

var password = 'fjcqy527038'
var publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCRD8YahHualjGxPMzeIWnAqVGMIrWrrkr5L7gw+5XT55iIuYXZYLaUFMTOD9iSyfKlL9mvD3ReUX6Lieph3ajJAPPGEuSHwoj5PN1UiQXK3wzAPKcpwrrA2V4Agu1/RZsyIuzboXgcPexyUYxYUTJH48DeYBGJe2GrYtsmzuIu6QIDAQAB";
console.log('JSEncrypt RSA encrypt: ', fun_rsa_encrypt(password, publicKey))

其他

//window.common.token一般这种window.xxx.xxx一般是服务器返回的数据

//js内置变量直接设置
//navigator = this;
//window = this;
//location = this;

如何让 (a == 1 && a == 2 && a == 3) 返回 true

// === 是严格相等，不仅需要两个变量的值相同，还需要类型也相同。 == 是宽松下的相等，只需要值相同就能够判断相等，宽松相等是严格相等的父集。

// a 为 Object ，使用 toString
//const a = {
//  i: 1,
//  toString: function () {
//    return a.i++;
//  }
//}

//a 为 Object ，使用 valueOf
//const a = {
//  i: 1,
//  valueOf() {
//    return this.i++
//  }
//}

// 在 ES6 中 JS 新增了 Proxy 对象，能够对一个对象进行劫持，接受两个参数，第一个是需要被劫持的对象，第二个参数也是一个对象，内部也可以配置每一个元素的 get 方法：
//var a = new Proxy({ i: 1 }, {
//  get(target) { return () => target.i++ }
//});
//
//if (a == 1 && a == 2 && a == 3) {
//  console.log('Hello World!');
//}

console.log('null == undefined: ', null == undefined) // true
console.log('null === undefined: ', null === undefined) // false

console.log("1 == '1': ", 1 == '1') // true
console.log("1 === '1': ", 1 === '1') // false

js中=＞的作用 以及与=＞{}的区别

//(x) => x + 6
//相当于
//function(x){ return x + 6; }
//
//（v,k）=>k
//相当于
//function(v,k){ return k }
//
//(x) => x + 6
//相当于
//function(x){ return x+6 }
//
//()=>{}
//相当于
//function(){}
//
//(x)=>{ return x+6 }
//相当于
//function(x){ return x + 6; }

//const md5 = str => CryptoJS.MD5(str).toString()
//相当于
//function md5(str){
//    return CryptoJS.MD5(str).toString()
//}