20190315杂七杂八

244 阅读7分钟

数组的定义、操作与方法

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("程序执行完毕");