20190315杂七杂八

╰半橙微兮° 2022-01-20 11:13 276阅读 0赞

#### 数组的定义、操作与方法 ####

1.数组的定义 有两种方式，字面量定义数组或者new关键字定义数组

var arr = (1,2,3,[4,5,6],{});
    var arr = new Array[1,2,3,[4,5,6],{}];
    var arr = new Array(5);
    复制代码

1.  数组添加元素
    
     *  方法1
        
            var arr = [1,2,3,4,"A"];
             arr[5] = "M"; //如果为数组元素赋值的索引i大于数组长度，则添加数组元素后的数组长度为 i+1
            复制代码
     *  方法2:push()
        
            var arr = [1,2,3,4,"A"];
            arr.push("BB","cc");//在数组元素的后面添加，可以追加多个元素，
            复制代码
     *  方法3:unshift()
        
            var arr = [1,2,3,4,"A"];
             arr.unshift("BB","cc");//在数组元素的前面添加，可以追加多个元素，
            复制代码
2.  删除数组元素
    
     *  方法1：pop()方法，删除最后一个元素
        
            var arr = ["A", "B", "C", "D"];
            arr.pop(); //删除最后一个元素，没有参数，每次只能删除一个
            复制代码
     *  方法2：shift()元素，删除第一个元素
        
            var arr = ["A", "B", "C", "D"];
            arr.shift(); //删除第一个数组元素，没有参数，每次只能删除一个
            复制代码
3.  修改数组
    
        var arr = ["A", "B", "C", "D"];
         arr[2] = "E";
        复制代码
4.  数组中常见的方法
    
     *  join():将数组中的元素，使用某种符号连接起来，形成一个字符串
        
            var arr = ["A","B","C","D"]
                var a = arr.join("*")
                console.log( a);
                var a = arr.join("+")
                console.log( a);
                var a = arr.join("-")
                console.log( a);
                var a = arr.join("/")
                console.log(a);
                console.log(typeof a);
            
            复制代码
     *  reverse():将数组中的元素倒置顺序
        
            var arr = ["A","B","C","D"]
                  var a = arr.reverse();  //倒置数组顺序
            复制代码
     *  concat():将多个数组拼接成一个数组,其中的多维数组是不会展开的
        
            var arr = ["A","B","C","D"];
                 var arr1 = ["A","B","C","D"];
                 var arr2 = ["A","B","C","D"];
                 var arr3 = ["A","B","C","D" ,[1,2,3]];
                 var a = arr.concat(arr1,arr2,arr3) //concat将多个数组拼接成一个数组,其中的多维数组是不会展开的 
            复制代码
     *  sort():截取数组中的元素
        
            var a = arr.slice(1,3); //截取的元素包括开始截取的元素，但是不包括最后截取的元素
                     console.log(a);
                     var a = arr.slice(1); //只写一个则表示截取到最后一个元素
                     console.log(a);
            复制代码
     *  toString():将数组转换成字符串类型
        
            var arr = ["A","B","C","D"];
                  var a = arr.toString();
                  console.log(a);        
            复制代码

--------------------

#### 数组转字符串 ####

var a, b;
    a = new Array(0,1,2,3,4);
    b = a.join("-");
    //或者
    var a, b;
    a = [0,1,2,3,4,0];
    b = a.join(",");
    console.log(b)//0,1,2,3,4,0
    复制代码

#### 字符串转数组 ####

var str = "abc,abcd,aaa";
    arr = str.split(",");// 在每个逗号(,)处进行分解。
    console.log(arr)//["abc", "abcd", "aaa"]
    复制代码

#### 将一个值转换为字符串 ####

*  value.toString()
 *  ""+value
 *  String(value)

第一种方法不能把null和undefined转换为字符串

#### 如何判断undefined ####

用value==undefined或者typeof(value)==undefined都是不对的，要用typeof(value)=="undefined",因为value为null时，也与undefined相等，虽然null和undefined不一样，另外，**typeof返回的是字符串**，有六种可能：

“number”，“string”，“boolean”，“object”，“function”，“undefined”

var value=undefined;
    if(typeof(value)=="undefined"){
        alert("undefined")
    }
    复制代码

#### 如何判断null ####

用value==null是不对的，因为value为undefined时也会得到与null同样的结果；用！value也是不对的，因为value为undefined或者数字零时也会得到与null同样的结果。以下是正确的写法

var value=null;
    if(!value&&typeof(value)!="undefined"&&value!=0){
        alert("null")
    }
    复制代码

尽管如此，我们在 DOM 应用中，一般只需要用 (!exp) 来判断就可以了，因为 DOM 应用中，可能返回 null，可能返回 undefined，如果具体判断 null 还是 undefined 会使程序过于复杂。

#### 不同场景下，在node中如何写文件 ####

Sream是一个抽象接口。Node中有很多对象实现了这个接口，例如对`HTTP`服务器发起请求的`request`对象就是一个Stream，还有`stdout`。Node中Stream有四种流类型，`Readable、Writeable、Duplex和Transform`（操作被写入数据，然后读出结果）。所有的Stream对象都是`EventEmitter`的实例，常用的事件有`data、end、err、finish`。

**总结：**

对于写数据，**如果我们是程序中的数据比如数组写入TXT文件中**，**如果我们是一次性写入**，那么就不需要用流，直接用`fs.writeFile`，即一次性读完数据写入的小文件比较适合用`fs.writeFile`，注意这个函数必须要有一个回调函数，不然会报错；**如果是多次写入到文件**，比如我们每次写入数组中的一个元素，那么最好使用`fs.createReadStream`，使用流建立与文件的连接，然后每次都可以用`write`来写（注意这里会覆盖，如果想追加的话在`fs.createReadStream`中添加第二个参数`{ 'flags': 'a'}`），虽然也可以使用`fs.writeFile`,但是这样会写入到文件中的元素可能会顺序错乱，所以这种情况下最好还是用流。**如果我们是将一个文件的内容写到另一个文件中**，那么就应该使用管道流，这时候就像文件复制一样，另个文件的内容以及排列布局都是一样的。

1.  从流中读取数据
    
        var fs = require("fs");
        var data = '';
        
        // 创建可读流
        var readerStream = fs.createReadStream('input.txt');
        
        // 设置编码为 utf8。
        readerStream.setEncoding('UTF8');
        
        // 处理流事件 --> data, end, and error
        readerStream.on('data', function(chunk) {
           data += chunk;
        });
        
        readerStream.on('end',function(){
           console.log(data);
        });
        
        readerStream.on('error', function(err){
           console.log(err.stack);
        });
        
        console.log("程序执行完毕");
        复制代码
2.  写入流
    
        var fs = require("fs");
        var data = '百度：www.baidu.com';
        
        // 创建一个可以写入的流，写入到文件 output.txt 中
        var writerStream = fs.createWriteStream('output.txt');
        
        // 使用 utf8 编码写入数据
        writerStream.write(data,'UTF8');
        
        // 标记文件末尾
        writerStream.end();
        
        // 处理流事件 --> data, end, and error
        writerStream.on('finish', function() {
            console.log("写入完成。");
        });
        
        writerStream.on('error', function(err){
           console.log(err.stack);
        });
        
        console.log("程序执行完毕");
        复制代码
    
    1.  管道流
        
        管道提供了一个输出流到输入流的机制。通常我们用于从一个流中获取数据并将数据传递到另外一个流中。管道流比较适合大文件的整体复制。
        
            var fs = require("fs");
            
            // 创建一个可读流
            var readerStream = fs.createReadStream('input.txt');
            
            // 创建一个可写流
            var writerStream = fs.createWriteStream('output.txt');
            
            // 管道读写操作
            // 读取 input.txt 文件内容，并将内容写入到 output.txt 文件中
            readerStream.pipe(writerStream);
            
            console.log("程序执行完毕");
            复制代码
    2.  链式流
        
        链式是通过连接输出流到另外一个流并创建多个流操作链的机制。链式流一般用于管道操作。
        
        接下来我们就是用管道和链式来压缩和解压文件。
        
            var fs = require("fs");
            var zlib = require('zlib');
            
            // 压缩 input.txt 文件为 input.txt.gz
            fs.createReadStream('input.txt')
              .pipe(zlib.createGzip())
              .pipe(fs.createWriteStream('input.txt.gz'));
              
            console.log("文件压缩完成。");
            复制代码
        
        执行完以上操作后，我们可以看到当前目录下生成了 input.txt 的压缩文件 input.txt.gz。
        
        接下来，让我们来解压该文件
        
            var fs = require("fs");
            var zlib = require('zlib');
            
            // 解压 input.txt.gz 文件为 input.txt
            fs.createReadStream('input.txt.gz')
              .pipe(zlib.createGunzip())
              .pipe(fs.createWriteStream('inputtest.txt'));
              
            console.log("文件解压完成。");
            复制代码
        
         执行完以上操作后，我们可以看到当前目录下生成了 inputtest.txt 文件
        
        **补充问题：**
        
        我现在又这么一个需求，我想把input里面的内容写到outInput里面去，但是上面的方法都是把文档里面的内容重置了，我只想添加，而且保留原内容怎么办呢？下面有两种方法
        
        1.  设置**写入流的追加参数**
            
                var fs = require("fs");
                
                // 创建一个可读流
                var readerStream = fs.createReadStream('input.txt');
                
                // 创建一个可写流
                //设置第二个参数append
                var writerStream = fs.createWriteStream('output.txt',{ 'flags': 'a' });
                
                // 管道读写操作
                // 读取 input.txt 文件内容，并将内容写入到 output.txt 文件中
                readerStream.pipe(writerStream);
                
                console.log("程序执行完毕");
                复制代码
        2.  可以在可读流创建完毕的回调函数里面进行操作
        
            let fs = require('fs');
            let data = '';
            let data2 = '你的小青蛙是真的可爱';
            //1.读取流
            //创建可读流
            let readStream = fs.createReadStream("input.txt");
            //设置utf-8编码
            readStream.setEncoding('UTF8');
            //处理流事件
            readStream.on('data', chunk => data += chunk);
            readStream.on('end', () => writeS(data));
            readStream.on("error", err => console.log(err.strck));
            console.log("程序1执行完毕");
            //2.写入流
            //创建可写流
            let writeS = dataS =>{
                let writeStream = fs.createWriteStream("outInput.txt");
                //使用utf-8写入流 
                writeStream.write(data2+dataS, "UTF8");
                //标记文件末尾
                writeStream.end();
                //处理事件流 
                writeStream.on("finish", () => console.log("写入完成")); 
                writeStream.on("error", err => console.log(err.stack));   
                console.log("程序2执行完毕");
            }
            复制代码
        
        **完整实例：**
        
            //createReadStream.js
            const fs = require('fs')
            //流的方式读取文件
            var readStream=fs.createReadStream('input.txt');
            var str='';/*保存数据*/
            var count=0;  /*次数*/
            readStream.on('data',function(chunk){
                str+=chunk;
                count++;
            
            })
            //读取完成
            readStream.on('end',function(chunk){
                console.log(count);
                console.log(str);
            
            })
            //读取失败
            readStream.on('error',function(err){
                console.log(err);
            
            })
            //writeStream.js
            
            var fs = require("fs");
            var data = '我是从数据库获取的数据，我要保存起来11\n';
            
            // 创建一个可以写入的流，写入到文件 output.txt 中
            var writerStream = fs.createWriteStream('output.txt');
            for(var i=0;i<100;i++){
                writerStream.write(data,'utf8');
            
            }
            //标记写入完成
            writerStream.end();
            writerStream.on('finish',function(){
                console.log('写入完成');
            })
            //失败
            writerStream.on('error',function(){
                console.log('写入失败');
            })
            var fs = require("fs");
            // 创建一个可读流
            var readerStream = fs.createReadStream('input.txt');
            // 创建一个可写流
            var writerStream = fs.createWriteStream('output.txt');
            // 管道读写操作
            // 读取 input.txt 文件内容，并将内容写入到 output.txt 文件中
            readerStream.pipe(writerStream);
            console.log("程序执行完毕");
            复制代码