使用ng build --prod 打包时，报错：

下面是开发环境：

求教大佬们，怎么解决啊？

有升级过angular-cli，还是同样状况。

原文地址：JavaScript30秒， 从入门到放弃之Array（四）

博客地址：JavaScript30秒， 从入门到放弃之Array（四）

水平有限，欢迎批评指正

maxN

Returns the n maximum elements from the provided array. If n is greater than or equal to the provided array’s length, then return the original array(sorted in descending order).

Use Array.sort() combined with the spread operator (...) to create a shallow clone of the array and sort it in descending order. Use Array.slice() to get the specified number of elements. Omit the second argument, n, to get a one-element array.

const maxN = (arr, n = 1) => [...arr].sort((a, b) => b - a).slice(0, n);

返回一个数组的前n个最大值，如果指定的n大于或等于指定数组的长度，那么将返回原数组（按降序排列后）。

使用Array.sort()和ES6的扩展运算符…来生成一个按降序排列的浅度复制数组。使用Array.slice()来截取指定个数的数组元素。若省略第二个参数n时，n=1。

➜  code cat maxN.js
const maxN = (arr, n = 1) => [...arr].sort((a, b) => b - a).slice(0, n);

console.log(maxN([1, 2, 3]));
console.log(maxN([1, 2, 3], 2));

➜  code node maxN.js
[ 3 ]
[ 3, 2 ]

主要看懂这个sort就好了：

sort((a, b) => b - a)

这是降序排的方法，怎么讲？

变形一：

sort(fn(a，b))

这个fn呢有两个参数a、b就是数组排序是按顺序相邻的两个数组元素。a前、b后。

变形二：

sort((a, b) => {
  if (b > a) {
    return 1;
  } else if (b < a) {
    return -1;
  }
  return 0;
})

return1表示把前面的数a放后面，后面的数b在放前面；return0表示不换位置；return-1表示前面的数a放前面，后面的数b放后面。

例子中，当b > a时把a换到b后面，意即把大数放前边了，即降序排列。反之升序排列。

slice(0, n)

排完之后slice(0, n)截取前n个元素组成的数组即为数组最大的前n个数。

minN

Returns the n minimum elements from the provided array. If n is greater than or equal to the provided array’s length, then return the original array(sorted in ascending order).

Use Array.sort() combined with the spread operator (...) to create a shallow clone of the array and sort it in ascending order. Use Array.slice() to get the specified number of elements. Omit the second argument, n, to get a one-element array.

const minN = (arr, n = 1) => [...arr].sort((a, b) => a - b).slice(0, n);

返回一个数组的前n个最小值，如果指定的n大于或等于指定数组的长度，那么将返回原数组（按升序排列后）。

使用Array.sort()和ES6的扩展运算符…来生成一个按升序排列的浅度复制数组。使用Array.slice()来截取指定个数的数组元素。若省略第二个参数n时，n=1。

➜  code cat minN.js
const maxN = (arr, n = 1) => [...arr].sort((a, b) => a - b).slice(0, n);

console.log(maxN([1, 2, 3]));
console.log(maxN([1, 2, 3], 2));

➜  code node minN.js
[ 1 ]
[ 1, 2 ]

sort((a, b) => a - b)与maxN相反，命题得证！

nthElement

Returns the nth element of an array.

Use Array.slice() to get an array containing the nth element at the first place. If the index is out of bounds, return []. Omit the second argument, n, to get the first element of the array.

const nthElement = (arr, n = 0) => (n > 0 ? arr.slice(n, n + 1) : arr.slice(n))[0];

返回指定数组的第n个元素（索引从0算起）。

使用Array.slice()截取数组，使截取的数组的第一个元素就是nth对应的元素。如果索引n超过数组范围，返回空数组[]。省略第二个参数n，按n=0计。

➜  code cat nthElement.js
const nthElement = (arr, n = 0) => (n > 0 ? arr.slice(n, n + 1) : arr.slice(n))[0];

console.log(nthElement(['a', 'b', 'c'], 1));
console.log(nthElement(['a', 'b', 'b'], -3));

➜  code node nthElement.js
b
a

就是简单的用slice去截取元素，取截取后的第一个元素即可。

partition

Groups the elements into two arrays, depending on the provided function’s truthiness for each element.

Use Array.reduce() to create an array of two arrays. Use Array.push() to add elements for which fn returns true to the first array and elements for which fn returns false to the second one.

const partition = (arr, fn) =>
  arr.reduce(
    (acc, val, i, arr) => {
      acc[fn(val, i, arr) ? 0 : 1].push(val);
      return acc;
    },
    [[], []]
  );

根据提供的方法对一个数组就行调用后，按运算结果的布尔值是否为真分类。为真，归到二维数组索引为0的数组中；为假，归到二维数组索引为1的数组中。

使用Array.reduce()生成一个1x2的二维数组。使用Array.push()把指定fn运算结果为true的数组元素添加到二维数组的第一个数组中，运算结果为false的数组元素添加到二维数组的第二个数组中。

➜  code cat partition.js
const partition = (arr, fn) => arr.reduce((acc, val, i, arr) => {
    acc[fn(val, i, arr) ? 0 : 1].push(val);
    return acc;
}, [
    [],
    []
]);

const users = [{
    user: 'Pony',
    age: 47,
    active: true
}, {
    user: 'barney',
    age: 36,
    active: false
}, {
    user: 'fred',
    age: 40,
    active: true
}];

console.log(partition(users, o => o.active));

➜  code node partition.js
[ [ { user: 'Pony', age: 47, active: true },
    { user: 'fred', age: 40, active: true } ],
  [ { user: 'barney', age: 36, active: false } ] ]

acc的默认值是一个1x2的二维空数组[[], []]。随着reduce的遍历过程将把满足对应条件的元素分别push到对应的数组中。

acc[fn(val, i, arr) ? 0 : 1].push(val);

fn(val, i, arr)如果为true将会把对应的元素val添加到acc的索引为0的数组中，否则添加到索引为1的数组中。这样遍历结束就达到了分组的目的。

例子中，fn是o => o.active就是根据对象的active的属性是否为true进行分类，所以我们看到，user为Pony和fred的元素都在二维数组的索引为0的数组中，其它在二维数组的索引为1的数组中。

pull

Mutates the original array to filter out the values specified.

Use Array.filter() and Array.includes() to pull out the values that are not needed. Use Array.length = 0 to mutate the passed in an array by resetting it’s length to zero and Array.push() to re-populate it with only the pulled values.

(For a snippet that does not mutate the original array see without)

const pull = (arr, ...args) => {
 let argState = Array.isArray(args[0]) ? args[0] : args;
 let pulled = arr.filter((v, i) => !argState.includes(v));
 arr.length = 0;
 pulled.forEach(v => arr.push(v));
};

改变原数组使其过滤掉指定的那些元素。

使用Array.filter()和Array.includes()剔除数组里不需要的元素。先用Array.length = 0把原数组变成空数组，然后再通过Array.push()把过滤后剩余的元素重新填充进去。

（类似方法不改变原数组的请看without方法）

➜  code cat pull.js
const pull = (arr, ...args) => {
    let argState = Array.isArray(args[0]) ? args[0] : args;
    let pulled = arr.filter((v, i) => !argState.includes(v));
    arr.length = 0;
    pulled.forEach(v => arr.push(v));
};

let myArray = ['a', 'b', 'c', 'a', 'b', 'c'];
pull(myArray, 'a', 'c');
let secondArray = ['a', 'b', 'c', 'a', 'b', 'c'];
pull(secondArray, ['a', 'c'], 'b');

console.log(myArray);
console.log(secondArray);

➜  code node pull.js
args:  [ 'a', 'c' ]
args:  [ [ 'a', 'b' ], 'c' ]
[ 'b', 'b' ]
[ 'c', 'c' ]

let argState = Array.isArray(args[0]) ? args[0] : args;

判断args的第一个元素是不是一个数组，如果是，把该数组赋值给argState作为后续排除数组元素的元数组；否则args就是元数组。

let pulled = arr.filter((v, i) => !argState.includes(v));

结合filter和includes把数组arr中包含在argState中的元素排除掉。

arr.length = 0;
pulled.forEach(v => arr.push(v));

此处，把数组长度设为0，将数组置空，然后再遍历pulled，把所有pulled的元素push到arr中，最终arr就只含有排除掉指定元素后的其他元素。

pullAtIndex

Mutates the original array to filter out the values at the specified indexes.

Use Array.filter() and Array.includes() to pull out the values that are not needed. Use Array.length = 0 to mutate the passed in an array by resetting it’s length to zero and Array.push() to re-populate it with only the pulled values. Use Array.push() to keep track of pulled values

const pullAtIndex = (arr, pullArr) => {
 let removed = [];
 let pulled = arr
   .map((v, i) => (pullArr.includes(i) ? removed.push(v) : v))
   .filter((v, i) => !pullArr.includes(i));
 arr.length = 0;
 pulled.forEach(v => arr.push(v));
 return removed;
};

改变原数组使其过滤掉指定的那些索引值对应的元素。

使用Array.filter()和Array.includes()剔除数组里不需要的元素。先用Array.length = 0把原数组变成空数组，然后再通过Array.push()把过滤后剩余的元素重新填充进去。同时使用Array.push()跟踪记录剔除掉的所有元素。

➜  code cat pullAtIndex.js
const pullAtIndex = (arr, pullArr) => {
    let removed = [];
    let pulled = arr.map((v, i) => (pullArr.includes(i) ? removed.push(v) : v))
        .filter((v, i) => !pullArr.includes(i));

    arr.length = 0;
    pulled.forEach((v) => arr.push(v));
    return removed;
};

let myArray = ['a', 'b', 'c', 'd'];
let pulled = pullAtIndex(myArray, [1, 3]);

console.log('myArray: ', myArray);
console.log('pulled: ', pulled);

➜  code node pullAtIndex.js
myArray:  [ 'a', 'c' ]
pulled:  [ 'b', 'd' ]

let pulled = arr
  .map((v, i) => (pullArr.includes(i) ? removed.push(v) : v))
  .filter((v, i) => !pullArr.includes(i));

arr先map是为了把要排除掉的元素push到removed变量中。pullArr.includes(i) ? removed.push(v) : v这个三元运算符就是判断索引是否在要排除掉的指定索引数组pullArr中。如果在，添加到removed中，否则直接返回该元素。

接下来filter把arr中匹配pullArr的索引对应元素剔除掉。

arr.length = 0;
pulled.forEach((v) => arr.push(v));
return removed;

最后把arr置空后再填入满足条件的元素，然后返回剔除掉的元素组成的数组。

pullAtValue

Mutates the original array to filter out the values specified. Returns the removed elements.

Use Array.filter() and Array.includes() to pull out the values that are not needed. Use Array.length = 0 to mutate the passed in an array by resetting it’s length to zero and Array.push() to re-populate it with only the pulled values. Use Array.push() to keep track of pulled values

const pullAtValue = (arr, pullArr) => {
  let removed = [],
    pushToRemove = arr.forEach((v, i) => (pullArr.includes(v) ? removed.push(v) : v)),
    mutateTo = arr.filter((v, i) => !pullArr.includes(v));
  arr.length = 0;
  mutateTo.forEach(v => arr.push(v));
  return removed;
};

改变原数组使其过滤掉指定的那些值所匹配的元素们，返回剔除掉所有元素组成的数组。

使用Array.filter()和Array.includes()剔除数组里不需要的元素。先用Array.length = 0把原数组变成空数组，然后再通过Array.push()把过滤后剩余的元素重新填充进去。同时使用Array.push()跟踪记录剔除掉的所有元素。

➜  code cat pullAtValue.js
const pullAtValue = (arr, pullArr) => {
    let removed = [],
        pushToRemove = arr.forEach((v, i) => (pullArr.includes(v) ? removed.push(v) : v)),
        mutateTo = arr.filter((v, i) => !pullArr.includes(v));

    arr.length = 0;
    mutateTo.forEach((v) => arr.push(v));
    return removed;
};

let myArray = ['a', 'b', 'c', 'd'];
let pulled = pullAtValue(myArray, ['b', 'd']);

console.log('myArray: ', myArray);
console.log('pulled: ', pulled);

➜  code node pullAtValue.js
myArray:  [ 'a', 'c' ]
pulled:  [ 'b', 'd' ]

逻辑上和pullAtIndex差不多，差别就在一个是过滤索引，另一个是过滤值。

为此实现上就有了以下不同：

// pullAtIndex
arr.map((v, i) => (pullArr.includes(i) ? removed.push(v) : v))

// pullAtValue
arr.forEach((v, i) => (pullArr.includes(v) ? removed.push(v) : v))

一个用了arr.map，一个用了arr.forEach。

为什么呢？

arr.map后arr的元素是会改变的，但是对于要剔除掉索引来说要删除掉索引对应的值是否有变化是无关紧要的。而对于匹配值来说就不灵了，因为本来要剔除掉的值在map的过程中改变了，到filter的时候就匹配不出来了，就无法剔除了。

所以改成了arr.forEach，它是不改变数组元素的，没有副作用，不干扰后续filter。另外forEach的结果是undefined。

reducedFilter

Filter an array of objects based on a condition while also filtering out unspecified keys.

Use Array.filter() to filter the array based on the predicate fn so that it returns the objects for which the condition returned a truthy value. On the filtered array, use Array.map() to return the new object using Array.reduce() to filter out the keys which were not supplied as the keys argument.

const reducedFilter = (data, keys, fn) =>
  data.filter(fn).map(el =>
    keys.reduce((acc, key) => {
      acc[key] = el[key];
      return acc;
    }, {})
  );

根据一个条件对一个数组进行过滤，同时过滤掉不需要的键。

使用Array.filter()去过滤出指定方法fn对数组元素对象调用结果为真值的元素，对过滤后的数组使用Array.map()返回一个新的对象，对象包含的键值对是由Array.reduce()根据指定keys过滤掉不需要的键而组成的。

➜  code cat reducedFilter.js
const reducedFilter = (data, keys, fn) =>
    data.filter(fn).map(el =>
        keys.reduce((acc, key) => {
            acc[key] = el[key];
            return acc;
        }, {})
    );


const data = [{
    id: 1,
    name: 'john',
    age: 24
}, {
    id: 2,
    name: 'mike',
    age: 50
}];

console.log(reducedFilter(data, ['id', 'name'], item => item.age > 24));

➜  code node reducedFilter.js
[ { id: 2, name: 'mike' } ]

data.filter(fn)

数组data根据方法fn过滤掉了不满足条件的数组元素。

keys.reduce((acc, key) => {
  acc[key] = el[key];
  return acc;
}, {})

keys是最终要保留的键的数组，reduce的acc初始值是空对象{}，遍历过程中，把所有的el对象中键包含于keys数组所有键值对累加到acc对象中。

map(el => fn1)

最后联合map方法可以看出，最终返回的是一个数组，数组内包含fn1方法也就是keys.reduce方法返回的acc的对象。

remove

Removes elements from an array for which the given function returns false.

Use Array.filter() to find array elements that return truthy values and Array.reduce() to remove elements using Array.splice(). The func is invoked with three arguments (value, index, array).

const remove = (arr, func) =>
  Array.isArray(arr)
    ? arr.filter(func).reduce((acc, val) => {
        arr.splice(arr.indexOf(val), 1);
        return acc.concat(val);
      }, [])
    : [];

删除数组中以指定方法调用结果为false的所有元素。

使用Array.filter()来找出数组中所有运行指定方法结果为真的元素，使用Array.reduce()配合Array.splice()删除掉不需要的元素。func函数调用有三个参数(value, index, array)。

➜  code cat remove.js
const remove = (arr, func) =>
    Array.isArray(arr) ?
    arr.filter(func).reduce((acc, val) => {
        arr.splice(arr.indexOf(val), 1);
        return acc.concat(val);
    }, []) : [];

const arr = [1,2,3,4];
console.log(remove(arr, n => n % 2 == 0));
console.log(arr);

➜  code node remove.js
[ 2, 4 ]
[ 1, 3 ]

Array.isArray(arr) ? filterfun : [];

先判断给定参数arr是否是一个数组，是，执行filter函数；否，直接返回结果空数组[]。

arr.filter(func).reduce((acc, val) => {
  arr.splice(arr.indexOf(val), 1);
  return acc.concat(val);
}, [])

arr.filter(func)首先过滤出func运行结果为真所有数组元素。reduce方法将filter剩余的所有数组元素以concat的方式返回结果数组。而在原数组arr中，则用splice将func运行结果为真的所有元素剔除。

其实就最终的返回结果来说，arr.filter(func)已经可以返回正确的结果，之所以看起来多此一举的使用了reduce的原因在于必须把不需要的元素从原数组arr中剔除。

以下是我在没看代码之前根据例子运行结果先写的代码：

➜  code cat remove1.js
const remove = (arr, fn) => {
  let removed = [];
  arr.forEach(v => (fn(v) ? removed.push(v) : v));
  const left = arr.filter(v => !fn(v));

  arr.length = 0;
  left.forEach(v => arr.push(v));

  return removed;
};

const arr = [1,2,3,4];
console.log(remove(arr, n => n % 2 == 0));
console.log(arr);

➜  code node remove1.js
[ 2, 4 ]
[ 1, 3 ]

我认为代码本身应该没什么问题，但可能没那么优雅，另外就是没有做Array.isArray的前置条件判断。

sample

Returns a random element from an array.

Use Math.random() to generate a random number, multiply it by length and round it of to the nearest whole number using Math.floor(). This method also works with strings.

const sample = arr => arr[Math.floor(Math.random() * arr.length)];

返回数组中随机的一个元素。

使用Math.random()生成一个随机数，乘以数组的长度，然后再配以Math.floor()获取整数索引，进而返回该索引对应的数组元素。这个方法也同样适用于字符串。

➜  code cat sample.js
const sample = (arr) => arr[Math.floor(Math.random() * arr.length)]

console.log(sample([3, 7, 9, 11]));

➜  code node sample.js
7

比如,在一个file.js里面, 引入fs模块 然后, 其中的一个函数中有一条语句是 fs.readdir(“某一个路径”,(err, files)=>{

});

然后其他的文件调用这个文件,比如入口文件调用这个文件file.js 在index.js中写到

var file = require("./models/file.js"); 调用: file.上面友fs.readdir语句的函数, 那么, Nodejs自带的模块,路径是相对于运行时,还是引入的时候?

2018也过去了二十天了。但好像没有看到关于Node.js的总结和发展展望,如果可以的话还是希望有大佬做一下。指导新人下一步的学习(哪些技术正在兴起,重点学习,哪些技术在衰落,可以放一边)

在跑egg-passport-github 的 demo 的时候，发现是直接 egg 的router进行视图渲染的，想问下如何在前后端分离的情况下，怎么做 github 登录

在 login.vue 里 直接 location.assign(‘http://127.0.0.1:7001/api/passport/github’) 这样可以跳转到github授权，但是callback之后又到egg的router里面了，如何再返回到前端并将 user info带回到前端呢？ctx.body = ctx.user;

求指教。

AI + IoT 领域， 工作地点位于杭州西溪湿地。

biao.zheng@rokid.com

我们可以提供：

• 在 AI+IoT 领域深度挖掘的机会
• 基于敏捷的开发流程
• 技术驱动的产品
• 全栈产品团队
• 提前把玩各种黑科技智能设备的机会
• 亲手打造 Javis 的机会

资深 JS 全栈开发（前端方向）

工作内容

• 高性能移动 Web 界面开发
• IoT 平台化开发
• 数据可视化
• 内部工具开发
• 全栈开发

要求

• 熟悉现代前端开发技术栈；
• 理解与掌握 React，Vue 并开发过产品；
• 掌握前端基础知识 HTML5， 浏览器渲染过程（ HTML，CSS3，JavaSript ）；
• 掌握各种前端开发调试技能
• IoT 玩家加分

资深 Node.js 开发工程师 (服务端)

工作内容

• 持续优化服务端架构
• 保障产品快速迭代进化
• 参与技术方案选型讨论
• Push Nodejs 在 IoT 领域的应用

要求

• 熟悉 NodeJS，有 NodeJS 开发经验，熟悉 Express\koa\eggjs 等框架；
• 熟悉 Node.js 标准库的使用，能完成相应的扩展开发
• 熟悉 Redis MongoDB，MySQL 各种数据库应用及优化，熟悉存储引擎及存储过程
• 有微服务开发经验优先
• 有运维能力优先
• 有大型网站开发经验者优先；
• 熟练使用 Linux 简单的运维工具

相册

CES 上展出的 Glass

办公环境

两代产品

最美语音开发版

我们是做Electron应用的，需要找个在客户端存数据用的库。 主要看中的点是：API简洁易懂，速度够快，每种操作有Callback方法。

看了大概四五个库的说明，有levelDb，pouchDB，LokiJS等等，整体感觉nedb不错。 查了半天，看到有人说，整个数据库最大只能达到256M，这个对我们来说还好。

请问，这个库还有其他坑需要注意吗？ 多谢各位

技术有点吐，大佬要多多指教。

用到的技术有 vue全家桶，hadoop

还在开发中，后期开源—

hadoop web-restfu-api 操作 配置图

点餐类的，单商户的，业务暂时不复杂 node不能做商城么？为什么有人这么说

如题

第一次访问没有问题，第二次访问会卡在执行SQL的地方。代码如下： tedious.js const Connection = require(‘tedious’).Connection;
const Request = require(‘tedious’).Request;

exports.mssql = function(config){
this.connection = new Connection(config);

this.query = function(str,callback){          //执行查询    
    var connection = this.connection;    
    var rows={};    
    connection.on('connect', function(err){                 //连接数据库，执行匿名函数    
        if(err){    
            callback({'err':err['message']+'请检查账号、密码是否正确,且数据库存在'});    
        }else{    
            var request = new Request(str,function(err, rowCount){      
                if(err)err = {'err':err['message']};    
                callback(err,rows);    
              //  connection.close();    
            });    
                
            var n=0;                        
            request.on('row', function(columns) {                            //查询成功数据返回    
                rows[n]={};    
                columns.forEach(function(column) {    
                        rows[n][column.metadata.colName] = column.value;        //获取数据              
                });    
                n++;    
            });    
            
            connection.execSql(request);                                 //执行sql语句    
        }    
    });    
}    

}

client2.js：

const request = require(‘request-json’); var client = request.createClient(‘http://192.168.1.83:8081/’);

var mssql = require(’./tedious.js’); var conn = new mssql.mssql({ ‘userName’: ‘sa’, ‘password’: ‘123’, ‘server’: ‘localhost’, ‘options’: { ‘port’: 1433, ‘database’: ‘WEIGHT20’ } });

var lastId = 0; var timeBw = 1 * 1000;

class postData { _getDate(fc) {

    console.log('取称重数据 ID', lastId);
    var sql = 'SELECT top 1  * FROM \u79f0\u91cd\u4fe1\u606f  where \u5e8f\u53f7>' + lastId + ' order by \u5e8f\u53f7 ';
    console.log('SQL', sql);
    conn.query(sql, function (err, data) {
        if (!err) {
            //console.log(data)       //成功返回数据    
            fc(data);
        }
        else {
            fc([]);
            console.log(err)      //出错返回    
        }
    }
    );
}
_postDate(item, fc) {
    lastId = item['\u5e8f\u53f7'];
    var postData = {};
    postData['creator_id'] = item['\u5e8f\u53f7'];
    postData['weight_id'] = 'code002';
    postData['weight_code'] = 'code002';
    postData['weight_rfid'] = '0';
    postData['veh_id'] = item['\u6d41\u6c34\u53f7'];
    postData['car_no'] = item['\u8f66\u53f7'];
    postData['weight_gross'] = item['\u6bdb\u91cd'];
    postData['weight_veh'] = item['\u76ae\u91cd'];
    postData['weight_net'] = item['\u51c0\u91cd'];
    postData['garbage_type'] = item['\u8d27\u540d'];
    postData['weight_date'] = item['\u76ae\u91cd\u65f6\u95f4'];
    postData['delivery_unit'] = item['\u53d1\u8d27\u5355\u4f4d'];
    postData['prj_id'] = 2;
    postData['tcar_company_id'] = 0;
    postData['creator_id'] = item['\u5e8f\u53f7'];
    console.log('post data', postData);
    client.post('/jsonapi/cancu_weight/add.json',
        postData, function (err, res, body) {
            if (err) {
                console.error(err);
            }
            else {
                console.log('post resp', body);
                fc({ code: 0 });
            }
        });
}

_time(fc) {
    var _self = this;
    _self._getDate((d) => {
        if (d.length <= 0) {
            fc({ code: -1 });
            return;
        }
        _self._postDate(d[0], fc);
    })
}

run(fc) {
    var _self = this;
    _self._time(d => {
        setTimeout(function () {
            _self.run();
        }, timeBw);
    }, timeBw)
}

}

var t = new postData(); t.run();

请各位大佬指点

各位大牛，新买的阿里云数据盘，想把mysql的数据挂在在数据盘下，操作如下： 在/mnt目录下创建mysql文件夹，命令：mkdir mysql

停掉mysql服务：命令：/etc/init.d/mysql stop

以新目录为/mnt/mysql/为例，复制原来的数据库到新目录下： 命令：cp -R /var/lib/mysql/* /mnt/mysql/

将新目录赋权为mysql组：命令：chown mysql:mysql -R /mnt/mysql/

修改配置文件： 首先打开配置文件：vim /etc/mysql/my.cnf

将datadir = /var/lib/mysql这一行修改为： datadir = /mnt/mysql

启动mysql：命令：/etc/init.d/mysql start

挂在后，发现数据存储后，数据盘占用的空间并没有变化，反而系统盘占用的空间变大了，想问是哪里出了问题呢？？？谢谢！！！

在vue移动端开发中，vux是一个比较好的UI模板，这个项目集成了vux，并在webpack中做了一些优化，避免开发过程中出现版本依赖，热更新出错更奇怪的问题，可以当作各种项目的一个空白模板 https://github.com/jinghaonode/vue-vux-demo

app.use(expressSession({
  resave: true,// 强制更新 session
  saveUninitialized: false,// 设置为 false，强制创建一个 session，即使用户未登录
  secret: 'session-cookie',
  store: new MongoStore({// 将 session 存储到 mongodb
    url: 'mongodb://localhost:27017/session-cookie'// mongodb 地址
  }),
  cookie: {maxAge: 1000 * 60 * 60}
}));

关闭浏览器后重新打开还是呈现登录状态，是缓存的原因吗？ 理论上 cookie 存放在浏览器内存中，关闭浏览器以后 cookie 就消失了

一开始的实验也验证了这个理论，重复多次后就出现相反的现象（关闭浏览器后重新打开还是呈现登录状态），是缓存吗？

npm install
npm WARN deprecated babel-preset-es2015@6.24.1:   Thanks for using Babel: we recommend using babel-preset-env now: please read babeljs.io/env to update! 
npm WARN deprecated isparta-loader@2.0.0: Package is deprecated, use https://github.com/deepsweet/istanbul-instrumenter-loader
Killed         ....] \ extract:webpack-merge: sill doParallel extract 699

Promise怎么实现while循环，触发条件跳出循环

公司描述

滴滴出行是国内发展速度最快的公司之一，并且是业内为数不多的技术驱动型公司，目前公司规模直逼业内一线大公司。 随着公司的快速发展，带来了大量的新机会和发展空间，如果你是个有理想有抱负的好青年，请加入我们一起成长。

团队描述

我们的技术栈 vue 负责前端部分，Node.js 负责后端部分，使用 BFF 架构开发模式，后续还有有移动端和可视化方向的产品研发，团队每周会有一次分享，氛围良好，期待你的加入。

职位描述

（业务层）参与公司内部基础服务的产品研发，包含管控平台和服务控制台，以及各服务的打通等。 （业务层）参与公司公有云产品的前端开发支持。 （研发层）参与团队自主研发的产品和技术框架的设计等。

招聘要求

• 1-3 年以上的前端开发经验
• 熟悉各种前端技术，包括 HTML/CSS/JavaScript/Node.JS 等，在 Web （ PC+Mobile ）/Node.js/Native App 三个方向上至少一个方向，具备多个的更佳
• 至少熟悉一门后端语言（如 Java/PHP/C/C++/Python/Ruby ）或 NodeJS，并有实践经验
• 熟练使用 Gitlab 进行项目代码管理以及版本控制，并遵循一定的流行规范。
• 有云产品或大数据产品等相关经历的背景优先考虑。
• 具有良好的团队协作精神，能利用自身技术能力提升团队整体研发效率，提高团队影响力；对前端技术有持续的热情，个性乐观开朗，逻辑性强，善于和各种背景的人合作

简历投放

简历发送至： hanbingango@didichuxing.com请注明来源：cnodejs

谢谢

使用request模块，下载服务器上的文件，使用stream的方式下载，如果先pause下，过段时间在resume，最后下载下来的文件 不完整，服务器上的文件是正常的

代码如下所示：

'use strict';
const request = require('request');
const timeout = 1000 * 60 * 3;
const fs = require('fs');
const path = require('path');
const sss = path.join(__dirname, '123123213.dmg');
const url = 'http://p2oryw9jc.bkt.clouddn.com/charles-proxy-4.1.4.dmg';
let inStream = request.get(url);
inStream.pause();
inStream.pipe(fs.createWriteStream(sss));
setTimeout(() => {
  inStream.resume()
}, timeout)

请问这是原因造成的呢，谢谢大家了