Node

var a = 2;
var b = a;
var c = a + 2;

var a = 1;
var b = { name: "bbb" }; // b 的值是对象在堆中的地址，对象存储在堆中，变量 b 存储在栈中

var obj1 = { name: "aaa" };
// 拷贝 obj1 的内容到 obj2, 只不过 obj1 的值是对象的地址，
// 所以 obj2 和 obj1 指向同一对象
var obj2 = obj1;

// 函数声明
function fn1() {
    console.log("fn1()");
}
// 函数表达式
var fn2 = function () {
    console.log("fn2()");
};

(function () {
    var a = 3;
    console.log(a + 3);
})();

function Person(color) {
    console.log(this)
    this.color = color
    this.setColor = function(color) {
        console.log(this)
        this.color = color
    }
}

Person("red")                  // window

var p = new Person("yellow")   // Person {}
p.setColor('red')              // Person { color: 'yellow'， setColor: [Function] }

var obj = {name: 'obj'}
p.setColor.call(obj， 'black') // { name: 'obj' }

// 如果不加分号就会出现 3(...)， TypeError: 3 is not a function
var a = 3
;(function(){

})()
// 如果不加分号，4[1， 2， 3] 返回 undefined， TypeError: Cannot read property 'forEach' of undefined
var b = 4
;[1，2，3].forEach(function(){

})

var p = {};

// p.content-type = 'text/json'

p["content-type"] = "text/json";

console.log(p["content-type"]);

var propName = "Age";

var propValue = 18;

p[propName] = propValue;

console.log(p[propName]);

function Fn() {}

console.log(Fn.prototype);
console.log(Fn.prototype.constructor);
console.log(Fn.prototype.constructor === Fn);

Fn.prototype.test = function () {
    console.log("test");
};
console.log(Fn.prototype);
var fn = new Fn();
fn.test();

console.log("---------------------------------");

function F0() {}

var f0 = new F0();

console.log(F0.prototype);
console.log(f0.__proto__);
console.log(f0.__proto__ == F0.prototype);

console.log("---------------------------------");

function F1() {}

function F2() {}

var F3 = new Function();
// 所有函数都是通过 new Function() 产生的，所以所有函数的 __proto__ 都相等, 都是 Function.prototype
// 因为 Function 也是通过 new Function() 产生的，所以 Function.__proto__ === Function.prototype
console.log(F1.__proto__);
console.log(F3.__proto__);
console.log(F1.__proto__ === F2.__proto__);
console.log(F1.__proto__ === Function.prototype);
console.log(F3.__proto__ === Function.prototype);
console.log(Function.__proto__ === Function.prototype);

console.log("---------------------------------");

// 1. 函数的显示原型指向的对象默认是空 Object 实例对象（Object例外)
console.log(Fn.prototype instanceof Object);
console.log(Function.prototype instanceof Object);
console.log(Object.prototype instanceof Object);

// 2. 所有函数都是 Function 实例，包括 Function
console.log(Function.__proto__ === Function.prototype);
console.log(Object.__proto__ === Function.prototype);

// 3. Object 的原型对象是原型链的尽头
console.log(Object.prototype.__proto__); // null

exports.hello = function () {
    console.log("Hello World!");
};

// 改变了 exports 指向， module.exports 不会导出 hello
exports = {
    hello: function () {
        console.log("Hello World!");
    },
};
// 可以使用 module.exports 直接导出对象
module.exports = {
    hello: function () {
        console.log("Hello World!");
    },
};

module.exports = function () {
    console.log("Hello World!");
};

-/home/ersu / hello / -util / counter.js;
main.js;

var i = 0;

function count() {
    return ++i;
}

exports.count = count;

var counter1 = require("./util/counter");
var counter2 = require("./util/counter");

console.log(counter1.count());
console.log(counter2.count());
console.log(counter2.count());

var fs = require("fs");

function copy(src, dst) {
    fs.createReadStream(src).pipe(fs.createWriteStream(dst));
}

function main(argv) {
    copy(argv[0], argv[1]);
}

main(process.argv.slice(2));

var fs = require("fs");
var rs = fs.createReadStream(src);

rs.on("data", function (chunk) {
    // 处理数据前暂停数据读取，并在处理数据后继续读取数据
    rs.pause(); //暂停
    doSomething(chunk, function () {
        rs.resume(); //继续
    });
});

rs.on("end", function () {
    cleanUp();
});

// 如果写入速度跟不上读取速度的话，只写数据流内部的缓存会爆仓。
// 我们可以根据 write 方法的返回值来判断传入的数据是写入目标了，还是临时放在了缓存了，
// 并根据 drain 事件来判断什么时候只写数据流已经将缓存中的数据写入目标， 可以传入下一个待写数据了。
// 因此代码可以改造如下：
var rs = fs.createReadStream(src);
var ws = fs.createWriteStream(dst);
rs.on("data", function (chunk) {
    if (ws.write(chunk) === false) {
        rs.pause();
    }
});

rs.on("end", function () {
    ws.end();
});

ws.on("drain", function () {
    //drain 排水，流干
    rs.resume();
});

function readText(pathname) {
    var bin = fs.readFileSync(pathname);

    if (bin[0] === 0xef && bin[1] === 0xbb && bin[2] === 0xbf) {
        bin = bin.slice(3);
    }
    return bin.toString("utf-8");
}

var iconv = require("iconv-lite");
function readGBKText(pathname) {
    var bin = fs.readFileSync(pathname);
    return iconv.decode(bin, "gbk");
}

// server
http.createServer(function (request, response) {
    response.writeHead(200, { "Content-Type": "text/plain" });

    request.on("data", function (chunk) {
        response.write(chunk);
    });

    request.on("end", function () {
        response.end();
    });
}).listen(80);

// client
var options = {
    hostname: "www.example.com",
    port: 80,
    path: "/upload",
    method: "POST",
    headers: {
        "Content-Type": "application/x-www-form-urlencoded",
    },
};

var request = http.request(options, function (response) {});

request.write("Hello World");
request.end();

var events = require("events");
var util = require("util");
var fs = require("fs");
var watchDir = "./watch";
var processDir = "./done";

// 创建文件监视器构造器
function Watcher(watchDir, processDir) {
    this.watchDir = watchDir;
    this.processDir = processDir;
}

// 继承事件发射器行为
util.inherits(Watcher, events.EventEmitter);

// 扩展事件发射器行为

// Node wacthFile 监控目录文件变动，触发 watch 方法
Watcher.prototype.start = function () {
    var watcher = this;
    fs.watchFile(this.watchDir, function () {
        watcher.watch();
    });
};

// wacth 方法对每一个文件发出 process 事件
Watcher.prototype.watch = function () {
    var watcher = this;
    fs.readdir(this.watchDir, function (err, files) {
        if (err) throw err;
        for (var index in files) {
            watcher.emit("process", files[index]);
        }
    });
};

var watcher = new Watcher(watchDir, processDir);

// 监听文件 process 事件，将文件名转换为小写从原始目录移动到目标目录
watcher.on("process", function process(file) {
    var wacthFile = this.watchDir + "/" + file;
    var processFile = this.processDir + "/" + file.toLowerCase();
    fs.rename(wacthFile, processFile, function (err) {
        if (err) throw err;
    });
});

watcher.start();

const arr = [
    [1, 2, 2],
    [3, 4, 5, 5],
    [6, 7, 8, 9, [11, 12, [12, 12, [13]]]],
    10
]

// 递归实现扁平化
Array.prototype.flat = function () {
    const result = this.map(item => {
        if (Array.isArray(item)) {
            return item.flat()
        }

        return [item]
    })

    return [].concat(...result)
}

// while 循环实现扁平化
Array.prototype.flat2 = function () {
    let result = this;

    while (result.some(item => Array.isArray(item))) {
        result = [].concat(...result)
    }
    return result;
}

Array.prototype.unique = function () {
    return [...new Set(this)]
}

const sortFn = (a, b) => a - b;

let result = arr.flat().unique().sort(sortFn)
console.log(result)
result = arr.flat2().unique().sort(sortFn)
console.log(result)

// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]