javaScript 初学

数据类型

//js中的数据类型:
//string,number,boolean,object,function
//3中对象类型
//Object，Date,Array
//2中不含值的数据类型
//null.undefined,
typeof "John"                 // 返回 string 
typeof 3.14                   // 返回 number
typeof NaN                    // 返回 number
typeof false                  // 返回 boolean
typeof [1,2,3,4]              // !!!返回 object
typeof {name:'John', age:34}  // 返回 object
typeof new Date()             // 返回 object
typeof function () {}         // 返回 function
typeof myCar                  // 返回 undefined (如果 myCar 没有声明)
typeof null                   // 返回 object

虽然js声明变量的时候可以不用var/let/const 等，用起来也差不多，但是却有着本质区别

var num = '1233'*1
console.log(typeof num);

 //声明num的时候不用加var，声明的是Windows的属性，可以被删除
 delete num;
 console.log(num);

数组，emmmmm，数组是可以扩容哒

var a = new Array("aaa","bbb","ccc")
console.log(a);
console.log(a[0]);
a[3] = 1998
console.log(a[3]);
a.forEach(key=>{console.log(key,typeof key);
})
//怎么说呢，这里如果log中就输出一种String类型，就没有引号，如果输入的有数字和String，String部分含有引号
console.log(typeofa[3])
console.log(a[3] ,typeof a[3])

new运算符
new运算符的作用是创建一个对象实例。这个对象可以是用户自定义的，也可以是带构造函数的一些系统自带的对象。如果 new 表达式之后的构造函数返回的不是JavaScript内置的引用对象（Object,String等）new会创建一个匿名对象并返回；如果是内置引用对象或者原始类型就会覆盖匿名对象。（无 return 时其实为 return 原始类型 undefined）。

Function
ECMAScript 的Function实际上就是一个功能完整的对象。而function这个关键字是用来创建所有对象的构造函数或者普通函数要用的关键字ECMAScript如何定义类和对象 ，比如var a=new function(){}实际上是用构造函数的方法创建了一个匿名对象的实例，而并不是系统内置对象Function的实例，所以a instanceof Function返回false，typeof返回”object”。

function fun()  {}
console.log(typeof fun);//function

var fun2 = new function(){}
console.log(typeof fun2);//object

var fun3 = fun.prototype;
console.log(typeof fun3);//object

function fun(){return 'hahaha'}
console.log(typeof fun,'\n',fun,'\n',fun.prototype);
console.log(fun instanceof Function)
/*
function 
 function fun(){return 'hahaha'} 
 fun {}
true
*/
//Function
//加括号和不加括号一样
var F = new Function;
var F2 = new Function();

console.log(typeof F);
console.log(typeof F2);//function
console.log(F);
console.log(F2);//[Function: anonymous]

object和Object的区别（大写小写）
typeof 返回的结果，是一个字符串。只要检查的变量是一个对象，或者是 Null，那它就会返回 object，这当然不够精确，所以有了 instanceof。

因为不存在 object 这个对象，所以会提示你 object is not defined 。而 Object 是 JavaScript 中一个重要的对象，其它对象都是基于它的，包括你创建的函数。你创建 a 的时候，使用的是 new 关键字，这相当于是一个 Function 引用类型的实例。所以 a instanceof Object 就会是 true。

区别是Object 是一种对象类型， “object”是一个字符串， 你不定义的话没有意义。

var date = new Date();
console.log(date);//2018-08-02T13:01:19.538Z

var obj = new Object(date);
console.log(obj);//2018-08-02T13:01:19.538Z

var sobj = new Object('ssss')
var schileobj = new Object(sobj)
console.log(sobj);//[String: 'ssss']
console.log(schileobj);//[String: 'ssss']

console.log(typeof obj);//object
console.log(typeof sobj);//object
console.log(obj instanceof Date) //true
console.log(obj instanceof obj.constructor)//true
console.log(schileobj instanceof obj.constructor)//false

js中，Object类型的声明，除了通常的new一个ojbect外，还有一下的方式

function Demo(){
    this.name="陈思";
    this.age=12;
    this.firstF=function(){
    }
    this.secondF=function(){
    }
    var obj2 = new Object()
    //return new Object();
    return true;
}

//惊了，这两种效果是一样的
//var one=new Demo
var one=new Demo();

// 调用输出
console.log(one,typeof one)

function Demo2(){
    this.sex = 'F';
    var obj = new Object();
    obj.name = '张一凡';
    obj.show= function(){
        console.log(this.name);
    }
    //return obj;
}
var two = new Demo2();
console.log(two,typeof two);


var Dobj = new Object()
Dobj.x = 'x';
console.log(Dobj);
var Dobj2 = new Dobj;
console.log(Dobj2);


/*
输出结果::
Demo { name: '陈思', age: 12, firstF: [Function], secondF: [Function] } 'object'
{ name: '张一凡', show: [Function] } 'object'

首先，看赋值方式，如果没有new，就是把整个函数体看做对象，那么变量就是function类型的，
如果含有new，而且函数的返回值是对象，那么new出来的就是这个对象,如果返回值是非对象类型，或者没有返回值，那么new出来的就是这个函数对象，Object类型
*/

const fs = require('fs')
//读取文件，编码为utf-8
fs.readFile(__dirname+'\\s2.js','utf-8',(err,data)=>{
    if(err){
       console.log(err);
        return false;
    }

    console.log(data,typeof data);
    //console.log(data.toString());


})

如果想循环执行异步操作，显然，传值得时候回遇到问题，这是因为异步函数是在循环结束后才执行的（可能），所以执行结果肯定不会像字面上那样，如果想用类似于同步的传值，除了用sync函数之外，可以考虑下面的做法

//异步函数转换成同步函数（其实也不是转换成同步函数）就是调用这个自执行函数（闭包？）让每次i的值都是当前不会变得局部变量

(function doit(i){
    if(i>4) return;
    setTimeout(()=>{
        console.log('now is ',i);

    },100)
    doit(++i)
})(0)
console.log('finish');


//利用自执行函数显示判断文件夹

var path = require('path')
fs.readdir('studyAgain',(err,files)=>{
    if(err) return ;
    console.log(files);;
    (function getfile(i){
        if(i == files.length) return ;
        console.log(files[i]);

        fs.stat(path.join('studyAgain',files[i]),(err,stats)=>{
            if(err) console.log('err:',err);

            console.log(i,':',stats.isDirectory());

        })
        getfile(++i)
    })(0)
})
console.error('finish')；

文件流(node环境)

写入流

//创建一个写入流
var writerStream = fs.createWriteStream('test.txt');
var data = 'Stream^Stream-----'

//写入十次数据
for(let i = 0 ;i < 10; i++)
writerStream.write(data);//['utf8']

//标记写入完成，就会广播finish和error
writerStream.end();
//如果不标记end，也能写入，但是不会触发下面给得事件
writerStream.on('finish',()=>{console.log('写入完成')})
writerStream.on('error',()=>{console.log('出错')})

读取流

//创建一个读取流
var readStream = fs.createReadStream('test.txt');
var str = '';
//当读取到数据的时候触发一次on事件
var count = 1;
readStream.on('data',stream=>{
    console.log('第',count++,'次读取');
    str += stream;
})
//读取到文件结尾的时候触发end事件
readStream.on('end',stream=>{
    console.log(str);
})
//当发生错误的时候触发error事件
readStream.on('error',err=>{console.error(err)})

js中的函数传参

function doit(...pr){
    for(let i = 0 ;i < pr.length;i++)
    console.log(pr[i])
}
doit('shao','shi',3.14)

/*
运行结果
shao
shi
3.14
*/
// 可以看到，js中也可以类似于java中的传参方式一样，不定长数组，而且数据类型可以不唯一

在ES6 中，提供了 let 关键字和 const 关键字。let 的声明方式与 var 相同，用 let 来代替 var 来声明变量，就可以把变量限制在当前代码块中。let 允许你声明一个作用域被限制在块级中的变量、语句或者表达式。与var关键字不同的是，它声明的变量只能是全局或者整个函数块的。使用 const 声明的是常量，其值一旦被设定便不可被更改。

js中=== 和 == 的区别：

1、对于 string、number 等基础类型，== 和 === 是有区别的

a）不同类型间比较，== 之比较"转化成同一类型后的值"看"值"是否相等，=== 如果类型不同，其结果就是不等。
b）同类型比较，直接进行 "值" 比较，两者结果一样。

2、对于 Array,Object 等高级类型，== 和 === 是没有区别的

进行 "指针地址" 比较

3、基础类型与高级类型，== 和 === 是有区别的

a）对于 ==，将高级转化为基础类型，进行 "值" 比较
b）因为类型不同，=== 结果为 false

4、!= 为 == 的非运算，!== 为 === 的非运算

var num=1；

var str="1"；

var test=1；

test == num   //true　相同类型　相同值 

test === num  //true　相同类型　相同值 

test !== num  //false test与num类型相同，其值也相同,　非运算肯定是false 

num == str   //true 　把str转换为数字，检查其是否相等。 

num != str   //false  == 的 非运算 

num === str  //false  类型不同，直接返回false 

num !== str  //true   num 与 str类型不同 意味着其两者不等　非运算自然是true啦

关于字符串中的引号问题

字符串中，双引号中用单引号，可以不加反斜杠 ，同理，单引号中的双引号，也不用加反斜杠
总之你语法上不会出现奇异就可以，用  `  这个符号，也可以表示字符串，中间可以用${变量名} 就可以显示变量

console.log('单引号\'');
console.log("单引号'");
console.log("双引号\"");
console.log('双引号"');

let aaa = '变量'
let num1 = 6;
let num2 = 4;
console.log(`${aaa}------${num1}+${num2}=${num1+num2}`);

/*
单引号'
单引号'
双引号"
双引号"
变量------6+4=10
*/

取模运算，之和左边的值得正负号有关

var one=13;
var two=true;
var three=one+two;
// 结果 three:14

js中还可以出现夺目运算符

比如我们平时写两个数取最大值，喜欢用三目元算符，js中还支持多目运算符
 var one = 1;
 var two = 2;
 var three = 3
 var maxn ;
 maxn = two>one?two>three?two:three:one;

//可以这样理解，如果最左边two<one 是true 就返回 two?three?two:three,否则就返回one
//这样就好理解了
 console.log(maxn);

constructor

constructor 属性返回所有 JavaScript 变量的构造函数。

//constructor
var str =  'sss';
var strC = str.constructor;
console.log(strC);//[Function: String]
console.log(String().toString)//[Function: toString]
var str3 = strC('dao')
console.log(str3);//dao
console.log(typeof str3)//string
var str4 = new String('tttt')
console.log(str4)//[String: 'tttt']
console.log(typeof str4);//object
//也就是说str.constructor 和 String()还是有本质区别的，前者是str类型的构造函数，但是后者是String类的构造函数，
//前者能构造一个字符串，后者则是一个String类

用constructor来产看对象是否为某种类（Array或者是Date）

function isDate(myDate) {
    return myDate.constructor.toString().indexOf("Date") > -1;
}

var date = new Date();
var Nodate = new Array();
if(isDate(date)) console.log('yes'); else console.log('no');//yes
if(isDate(Nodate)) console.log('yes'); else console.log('no');//no

js中的类型转换

//类型转换
// 任意类型可以通过tostring()向字符串转换
var b = true;
console.log(typeof b);//boolean
console.log(typeof b.toString(),"  ||  ",b.toString())//string   ||   true
//或者使用String()进行转换
var i = 10;
console.log(typeof String(i))//string
console.log(String({})) //[object Object]
//Number 可以将字符串转化成数字
//如果是非法数字字符串，则转化成NaN
var stri = '199';
var strs = 'sss';
console.log(Number(stri))//199
console.log(Number(strs),typeof Number(strs));//NaN 'number'(如果只log typeof 的话 ，是没有两边的单引号的)
console.log(typeof Number(strs))//number

//也可通过 字符串前面加一个 + 符号，转化成number类型
var ci = +stri 
console.log(typeof ci)//number
console.log(typeof +stri)//number
//注意空串转化成数字，是 0 
console.log(Number(""))//0
//空数组，转化成数字，也是0,如果数组有一个数字，则转化后是那个数字，如果不是一个，或者不能转化成数字类型的字符串，则是NaN
console.log(Number([]))//0
console.log(Number([999]))//999
console.log(Number([12,12]))//NaN
console.log(Number(['10']))//10
console.log(Number(function(){}))//NaN
//向Boolean类型转换
//字符串向Boolean类型转，只要不是""空串，就是true
console.log(Boolean("0"))//true
console.log(Boolean(""))//false
//总之，转Boolean能是false的，只有几种("",NaN,null,undefined)

#其它琐碎点

var a = [2, 30, 1, 8, 101, 10];
a.sort();
console.log(a) //[ 1, 10, 101, 2, 30, 8 ]
//Javascript 的sort()函数在默认情况下使用字母数字（字符串Unicode码点）排序。
a.sort((a, b) => a - b)
console.log(a)

//new Date() 1,没有参数可以返回当前时间，2，一个参数x可以返回当前时间加上x毫秒
//new Date(1,1,1) 代表1900+1年，2月，1日
//new Date(2018,1,1),代表的是2018,1月31日
console.log(new Date(2018, 1, 2)) ///2018-02-01T16:00:00.000Z
console.log(new Date(2016, 1, 1)) //2016-01-31T16:00:00.000Z