JavaScript自学笔记--基础部分上海时时乐走势图官

概括性总结:
不怎么理解的话也可以记住这个概括性诀窍:
碰到两个及两个以上的call都是让第一个参数执行,第一个参数必须是函数;
第二个参数是改变第一个参数中this;
第三个及第三个以后的参数作为实参传给第一个参数。

            console.log(d!=e);    //false

1、基本常识

浏览器的组成:1)shell部分

                             2)内核部分:(1)渲染引擎(语法规则和渲染)

                                                        (2)js引擎

                                                        (3)其他模块

JS特点:1)解释性语言

                2)单线程(同步、异步)

                3)ECMA标注

JS执行队列:轮转时间片(类似吃法)

主流浏览器                                            内核

IE                                                            trident

Chrome                                                  webkit/blink

firefox                                                     Gecko

Opera                                                      presto    

Safari                                                       webkit

面试题:
function fn(a,b){
    console.log(this);
    console.log(a);
    console.log(a b);
}
fn.call(1);
fn.call.call(fn);
fn.call.call.call(fn,1,2);
fn.call.call.call.call(fn,1,2,3);

             * 

2、基本语法

1、数据类型:1)原始值:Number    Boolean    String    undefined    null

                           2)引用值:array    Object    function    ...date    RegExp

2、" "的作用:1)数学运算    2)字符串链接:任何数据类型加字符串都等于字符串

3、逻辑运算符:    &&    ||    !

        3.1    &&运算符:只有前后两个表达式的情况,如果第一个表达式的结果为true,那么直接返回第二个表达式的结果。如果第一个表达式的结果为false时,直接返回第一个表达式的值(undefined、null、NaN、""、0、false的布尔值为false)。

   具体应用:短路语句

      var data = ...;

      data    &&    function(data)

        3.2    ||运算符:只有前后两个表达式的情况,如果第一个表达式的结果为true,那么直接返回第一个表达式的结果。遇见true就返回。

具体应用:浏览器兼容问题(IE浏览器和非IE浏览器的兼容)

div.onclick = function(e) {

var event = e || window.event;

}

        3.3    !运算符:转换成布尔值再取反

4、if     else    for

通过几个实例来了解。

计算2的N次幂

    var n = parseInt(window.prompt('输入:'));

    var count = 1;

    if (n == 0) {        console.log(count);    } else {        

    for (var i = 1; i <= n; i ) {            count *= 2;        }        

   console.log(count);    }

递归计算N的阶乘

function factorial(number) { 

 if (number == 0 || number == 1) {            return 1;        }

else {            return number * factorial(number - 1);        } 

}

斐波那契额数列

var n = parseInt(window.prompt('输入:'));    

var   first = 1,

        second = 1,

        third;    

if (n == 1 || n == 2) {        console.log("1");    }

else if (n >= 3) {

        for (var i = 0; i < n - 2; i )

                {third = first second;           

                 first = second;            

                second = third;}        

console.log(third);    }

反向输出一个三位数

var num = window.prompt("输入:");

var str = ""; 

for (var i = num.length - 1; i >= 0; i--){

 str =i;        }

console.log(str);

条件语句补充

switch case

var date = window.prompt('input');

switch(date) {

case "monday":

case "tuesday":

case "wednesday":

case "thursday":

case "friday":

        console.log("working");

        break;

case "saturday":

case "sunday":

        console.log("relaxing");

        break;

}

break:终止循环

continue:终止本次循环,进行下一个循环

5、typeof操作符:返回数据是什么类型的        类型转换

        5.1    六种数据类型:number、string、boolean、undefined、object、function

        5.2    显示类型转化

                1)String(mix)、Boolean(mix)、Number(mix):把对象转换成字符串/布尔/数字类型

                2)parseInt(string,radix):1)把对象转换成整型数字

                                                                   2)有两个参数的时候,以目标进制(第二个参数)为基底,转化成10进制

                3)parseFloat(只有一个参数):把对象转换成浮点类型数字

               4)toString(radix):1)把对象转换成字符串,用法与String不同        xxx.toString();

                                                        undefined和null不能用toString方法

                                                    2)以10进制为基底,转化成目标进制(参数)

        5.3隐式类型转化(内部都是调用显示类型转化)

                1)isNaN():判断一个数是不是NaN,返回boolean值(调用Number转化成数字再判断)

                2) /--/ /-(一元正负):转化成数字类型(调用Number转化成数字)

                3) 号:当加号两边有一个是string类型,就会调用String,把另一个也转化成字符串类型

                4) -*/:调用Number转化成数字类型

                5)&&    ||    !:调用boolean进行类型转化

                6)== != < > <= >=:返回boolean值

        5.4特殊:undefined == null    返回true                NaN == NaN    返回false(NaN跟谁都不等)

        5.5typeof返回的数据类型的类型是String类型

6、函数

        6.1函数声明:function test() {}

        6.2函数表达式(匿名函数表达式):var demo = function () {}

arguments是一个存放实参的数组

实现累加

function sum() {

        var result = 0;

        for (var i = 0; i < arguments.length; i ) {

        result = arguments[i];        }

        console.log(result);

        return; //1、终止函数 2、返回值    } 

       sum(1, 2, 3, 4, 5, 6, 7, 8, 9);

7、作用域

        7.1    函数的属性:[[scope]],里面存放的是函数的作用域,是一个隐式的属性

        7.2    执行期上下文(AO和GO):函数的每次执行都会产生一个执行期上下文,函数执行完毕后,执行期上下文销毁

        7.4    作用域链:[[scope]]中所储存的执行期上下文对象的集合,呈链式链接

举例

function a() {

            function b()

        } { 

           var b = 234;

        } 

       var a = 123;

        b(); 

       var glob = 100; 

       a();

a函数被定义:a.[[scope]] --> 0 : GO{}

a函数执行:a.[[scope]] --> 0 : AO{}        

                                                   1 : GO{} 

b函数被定义:b的[[scope]]就是a的[[scope]]

b函数执行: b产生一个AO{} 放在作用域链的顶端       

                                                  0 : b.AO{}

                                                   1 : a.AO{}        

                                                   2 : a.GO{}

function a() {

            function b() {

                function c() {} 

               c();

            } 

           b(); 

       } 

       a();

a函数被定义:a.[[scope]] --> 0 : GO

a函数执行: a.[[scope]] --> 0 : a.AO         a函数执行完,销毁a.AO,再次执行a函数,new a.AO

                                                    1 : GO

b函数被定义:b.[[scope]] --> 0 : a.AO

                                                      1 : GO

b函数执行: b.[[scope]] --> 0 : b.AO    b函数执行完,销毁b.AO,再次执行b函数,new b.AO

                                                   1 : a.AO

                                                   2 : GO

c函数被定义: c[[scope]] --> 0 : b.AO

                                                      1 : a.AO

                                                      2 : GO

c函数执行: c[[scope]] -->0 : c.AO       c函数执行完,销毁c.AO,再次执行c函数,new c.AO

                                                1 : b.AO

                                                2 : a.AO

                                                3 : GO

8、预编译

        8.1    预编译是发生在函数执行的前一刻

        函数声明          整体提升

        变量                   声明提升(提升 = 优先执行)

        8.2    任何变量未经声明,直接赋值,此变量就为全局对象所有

        8.3    一切声明的全局变量,都是window的属性(window就是全局的域)

        8.4    预编译的步骤

                8.4.1   1)创建AO对象

                            2)找形参和变量声明,将变量和参数名作为AO的属性名,值为undefined

                            3)将实参值和形参统一

                            4)在函数体里面找函数声明,值赋予函数体

举例:

    function fn(a) {

        console.log(a);

        var a = 123;

        console.log(a);

        function a() {}

        console.log(a);

        var b = function() {}

        console.log(b); 

   }

        fn(1);

AO {

        a : undefined, -->1-->function a (){}-->123 

       b ; undefined -->function (){}

    }

function test(a, b) {

        console.log(a); 

       c = 0;

        var c;

        a = 3;

        b = 2;

        console.log(b);

        function b() {}

        function d() {}

        console.log(b);

    }

    test(1);

AO {

        a : undefined,-->1 --> 3 

       b : undefined,-->function b () {}-->2

        c : undefined,-->0

        d : undefined-->function d () {}

    }

function test() {

        console.log(a); //function a () {}

        console.log(b); //undefined 

        var b = 234;

        console.log(b); //234

        a = 123;

        console.log(a); //123

        function a() {}

        var a;

        b = 234; 

       var b = function() {} 

       console.log(a); //123

        console.log(b); //function () {}

    }     test(1);

console.log(test); 

    function test(test) {

        console.log(test); 

        var test = 234; 

       console.log(test); 

        function test() {}

    } 

   test(1);

    var test = 123;

    console.log(test);

GO { 

       test:     undefined-- > function test(test) {                                                  

                    console.log(test); //function test () {} 

                    var test = 234;                                                                               -- > 123                           

                    console.log(test); //234

                    function test() {}

                    }

            }

AO {

        test: undefined-- > 1-- > function test() {}-- > 234

     }

a = 100; 

       console.log(a);//100 

       function fn () {

            console.log(a);//undefined

            a = 200;

            console.log(a);//200

            var a = 300;

            console.log(a);//300

        } 

       fn();

        var a;

GO {

            a : undefined--> 100 

       }

AO {

            a : undefined --> 200 --> 300

        }

百度面试题

function bar() {

        return foo; //直接返回,后面的赋值语句不执行

        foo = 10; 

       function foo() {} 

       var foo = 11;

    }

    console.log(bar());

AO {

        bar : undefined --> function foo () { ....}

    }

百度面试题

console.log(bar());

    function bar() {

        foo = 10;

        function foo() {}

        var foo = 11;

        return foo; 

   }

AO {

        bar : undefined --> 10 --> function foo () {...} --> 11

    }

a = 100;

    function demo(e) {

        function e () {}

        arguments[0] = 2;

        console.log(e);//2

        if (a) {//a = undefined 不执行 //if 里面不允许声明function

         var b = 123;

         function c() {}

}

        var c;

        a = 10; 

       var a; 

       console.log(b);//undefined 

       f = 123;

        console.log(c);//undefined

        console.log(a);//10

    }

    var a ;

    demo(1);

    console.log(a);//100 这里的a是全局变量

    console.log(f);//123

GO {

        a : undefined --> 100

        demo : undefined --> function () {}

        f :undefined --> 123

    }

AO {

        e : undefined --> 1 -->function e () {} --> 2 

       c : undefined

        b : undefined

        a : undefined --> 10

    }

9、立即执行函数

        9.1    目的:1)防止浪费空间,执行一次就立即释放

                              2)针对初始化功能的函数

        9.2    形式:建议用第一种形式

                              1)(function () {}())    

                              2)(function () {})()

几点说明:1.只有表达式才能被执行符号执行(函数表达式可以被执行,但是函数声明不可以)

                    2.被执行符号执行的表达式,会自动忽略函数的名称

                    3.只要能变成表达式,就能被执行符号执行

可被执行的例子:

var num = (function(a, b) {//返回的值给了num

        var c = a b;

        return c;

    }(1, 2));

不可被执行的例子:

function test() { 

       var a = 123;

        console.log(a); 

   } //函数声明,所以它不能被执行符号执行

    test();

面试题

说明:逗号(,)操作符,(2, 3)先看前面的表达式,如果前面的表达式需要计算的先计算,然后再计算后面的表达式,如果后面的表达式需要计算的话,就计算后面的表达式,都计算完之后,把后面的表达式的计算结果返回回去。

var f = (

         function f() {

             return "1";

         }, 

        function g() { 

            return 2;

         }

        )();

        console.log(typeof f);

10、闭包

        10.1    闭包的形成:两个或多个函数互相嵌套,把里面的函数保存到了外面函数的外部,形成闭包。

        10.2    闭包的效果:让局部的函数保存到全局

        10.3    闭包的危害:闭包会导致原有的作用域链不被释放,造成内存泄漏

        10.4    闭包的作用:

                1)    实现公有变量(函数累加器)

function add() { 

       var count = 0; 

       function demo() {

            count ;

            console.log(count);

        }

        return demo;//将demo函数保存到add函数外部

    }

    var counter = add();

    counter();

    counter();

执行几次,就进行几次的累加。

                2)可以做缓存(存储结构)

function eater() {

        var food = "";

        var obj = {

            eat: function() {

                console.log("i am eating " food);

                food = "";

            },

            push: function(myFood) { 

               food = myFood;

            }

        }

        return obj; //返回了eat和push,都和eater形成了闭包

    }

    var eater1 = eater();

    eater1.push('banana');

    eater1.eat();

                3)可以实现封装,属性私有化

                4)模块化开发,防止污染全局变量

闭包的例子:

按顺序打印出0~9

function test() {

        var arr = []; //arr数组里存储了10个函数

        for (var i = 0; i < 10; i ) {

            arr[i] = function() {

                document.write(i " "); //赋值语句,这个函数在这里不会执行,只有在执行函数的时候才会看函数内部的内容

            }

        }

        return arr;

    }

    var myArr = test();

    for (var j = 0; j < 10; j ) {

        myArr[j](); //在这里执行 arr[i] = function() { document.write (i " ");},执行的时候去判断i的值

    }    

以上代码的显示结果不正确,通过立即执行函数来解决

function test() {

        var arr = [];

        for (var i = 0; i < 10; i ) {

            (function(j) {

                arr[j] = function() {

                    document.write(j " ");

                }

            }(i));

        }

        return arr;

    }

    var myArr = test();

    for (var j = 0; j < 10; j ) {

        myArr[j]();

    }

11、对象

var ZhangSan = {

            name: "ZhangSan",

            age: 22,

            sex: "male",

            health: 100,

            somke: function () {

                console.log("i am somking!");

                this.health--;

            },

            ball: function () {

                console.log("i am playing ball");

                this.health ;

            }

        }

        ZhangSan.apet = "计算机系"; //添加属性

        console.log(ZhangSan.sex); //查看属性

        ZhangSan.age = 21; //修改属性

        delete ZhangSan.sex; //删除属性

        当一个对象的属性没声明就访问,会返回undefined

        11.1    对象的创建方法

                1)var obj = {}      plainObject     对象字面量/对象直接量

                2)构造函数创建方法:(1)系统自带的构造函数   

                                                                new Object();Arrary();Number();Boolean();String();Date();

                                                                var obj = new Object();<==>var obj = {};

                                                            (2)自定义

                                                                function Person() {}

                                                                var person = new Person();

        11.2    构造函数命名规则:大驼峰式命名规则   TheFirstName

                    函数命名规则  小驼峰式命名规则    theFirstName

        11.3    自定义构造函数

                   构造函数内部原理(new)

                    (1)在函数体最前面隐式的加上this = {}

                    (2)执行 this.xxx = xxx;

                    (3)隐式的返回this

function Car(color) {

            //var this = {

                    name : "xxx";

                    height : "xxx";

                    ...

};  

            this.color = color;

            this.name = "BMW";

            this.height = "1400"; 

           this.lang = "4900";

            this.weight = 1000; 

           this.health = 100;

            this.run = function () {

            this.health--;

            }

            //return this;

        }

        var car = new Car("red");

        var car1 = new Car("yellow");

function Person(name, height) {

            //var this = {} 

           this.name = name;

            this.height = height;

            this.say = function () {

                console.log(this.say);

             }

             return 123;//除了对象类型,返回其他任何类型的原始值都会转化成对象类型

             //return this;

        }

        console.log(new Person('xiaowang', 180).name);

        var person1 = new Person('xiaoliu', 175);

12、包装类

        12.1    原始值不可能有属性和方法,对象才有属性和方法(对象包括object、数组、function)

        12.2    原始值不能操作属性,只能通过包装类操作

var num = 123;//这个num是原始值,是没有属性和方法的

var num = new Number(123);//数字对象可以操作属性,也可以进行运算,但是在运算之后就变成了数字类型的了

同样的还有String和Boolean

var str = new String('abcd');//字符串对象

var bol = new Boolean('true');//布尔对象

通过包装类操作之后,可以操作以上变量的方法

num.abc = "abc";

str.abcd = "abcd";

undefined和null不可以

        12.3    隐式的发生包装类

var num = 4;

num.len = 3;

//隐式发生    new Number(4).len = 3;        在完成之后会自动删除len(delete)

console.log(num.len);

包装类的例子:

var str = "abc";

str = 1; //'abc1'

var test = typeof (str); //test = "String"

if (test.length == 6) {

test.sign = "typeof的返回结果可能为String";

//new String(test).sign = 'xxx'      调用包装类赋值给原始值

}

//重新new String(test).sign      但是没有赋值

console.log(test.sign);//undefined

 

                    console.log(person.name);    //老王

 

             * 

深层解题思路:
fn.call(1);call的第一个参数改变call前面函数里的关键字this所以输出1;后面没有参数所以a,b为undefined,相加结果为NaN;
fn.call.call(fn);这一块是个难点,不过也很好理解! fn.call 找到Function.prototype上的call方法(这也是一个函数,也是函数类
                 的一个实例,也可以继续调用call/apply等方法)我们可以把fn.call看成一个函数 A 那么接下就等于A.call(fn),这
                 里执行call方法,把 A 中的关键字this修改为函数 fn ,然后再把函数 A(fn.call) 执行;
fn.call.call.call(fn,1,2);通过上一条的原型链的方法我们可以把 fn.call.call.call 看成 A(fn.call.call).call 执行,此时括
                 里的参数 fn 已经作为函数执行了,所以就成了 A.call(1,2) 执行!1作为第一个参数改变 call 前面函数里的this,
                 后面的参数作为实参传递到函数的形参里!
fn.call.call.call.call(fn,1,2,3); 同上一条原理!

    2递增递减

答案:
fn.call(1);  // 1,undefined,NaN
fn.call.call(fn);   // fn,undefined,NaN
fn.call.call.call(fn,1,2);  //  1,2,NaN
fn.call.call.call.call(fn,1,2,3);  //  1,2,5

                           }

            console.log(d!==c);    //true

             * 

             *         实参必需与形参一一对应,在调用函数的时候,要把实参传够数量。如果有一个实参没有传,那它的值就是undefined

            var b2=false;

    语法:       (attr)变量名            对象里所有的属性名(key)

             *     声明全局作用域的方法

                            var n2=23.56;

                fn4();

            var u=undefined;

             *         函数(函数声明,不是函数调用)可以嵌套的,嵌套的函数(局部函数)可以访问父函数里的内容

                var f= e;

十二、函数进一步理解---函数参数

                console.log(i);

            var u=undefined;

 

             *                 自己与自己都不相等

            console.log(parseInt(s5));        //123

            var s3=' ';

             *         格式:由简单数据类型与复合数据类型任意组合而成的。它的数据是放在一对大括号当中,每个数据由一个键值对组成的,数据可以是0个也可以是多个,每个数据之间用逗号隔开,最后一个数据不能加逗号(如果加了逗号,那就会报错)

     *     停止循环,只不过它停止的是当次的循环,后面的循环还是会走

             *     2、实参  (也具备数组的特性,arguments)

             /*         4、String

                console.log(attr,person[attr]);

             *     参数是放在小括号里,可以放0个或者多个,每个参数用逗号隔开

            console.log(typeof s);        //string

             *     =、 =、-=、*=、/=、%=

                        var s2="kaivon";

                console.log(name);

                    console.dir(person);

                     *     for(var 变量名 in 对象){     

             *         变量或者函数是在函数内部声明的,它们的作用仅存在于声明的这个函数里

            console.log(String(num));    //12

                var texts=document.querySelectorAll("input[type=text]");

             * 运算符优先级

            

            

             for(var attr in color){

            var a=1;

             *     1、函数声明

                    break;

                

            console.log(286);    //28            5%5        0

                 * e=e 1;

                        console.log(Number(s6));        //NaN

             *             var 变量=function(参数){

        作用: 和for的功能一样,循环。要取到一个对象里的所有数据,只能用for in方法

             * 

             *     1、显式类型转换 -----我们自己认为操作的。

                }

                 * c=c 1;

             *             false

                

             *             1、函数名(参数)

             *                 要执行的代码

            console.log(7);    //7              1%5        1

             *             0、NaN转布尔值的结果为false,其它的转布尔值的结果为true

             *             转数字的结果为0

             *                 数字最小值:Number.MIN_VALUE

                    for(var i=0;i<arguments.length;i ){

             *     关系运算符会把结果转成布尔值

                        }

                function css(){

<script>

             *         函数、对象、数组都属于复合数据类型。

             *     它只能在函数内使用,是局部作用域

/*

             *     注意:作用域链会一层一层往外找,不会往里面找(儿子能找到爸爸的,但是爸爸不会找儿子的)

            var nul=null;

             * 语法

                                                 //undefinded是有存在,只是没有给值,而Null代表是不存在的意思、

            function person(name,age){

             *     window是一个全局对象,它本身在页面中任何位置都可以用,所以说全局变量可以在任何地方用

             *         实际上的参数,放在了函数调用的小括号里

            

            

            console.log(Boolean(n4));    //true

             *             2、直接在后面加上一对小括号(不能换行到下一行写)

             *      放在操作符的前面与后在都是一样的,让自己加1

                var age=undefined;*/

            

              最终的结果是49,但是这个运算结果不会输出,因为没有return

             *             不管它在函数内声明,还是在函数外声明

             */ 

             *                 要执行的代码

            document.onclick();

                }

             *             2、把函数声明变成函数表达式,在后加个一对小括号

             *         switch(变量){

            

                --a;

                        var u2;

       1.     function fn(name){

             *     之所以全局变量在任何地方都可以访问到,是因为全局变量它是window下的属性

             * 如果只操作自己

            for(var i=0;i<5;i ){

                        console.log(Number(s2));        //0

             *     <、>、<=、>=、==、!=、===、!==

 九、while              

             *             放在一对单引号或者双引号里,由0个或者多个字符组成的串

                           }

                        //说明现在传了两个参数,获取元素的属性值

                    

             * while

            console.log(Boolean(nul));    //false

                            console.log(NaN==NaN);        //false

                

             * 注意:当while的条件不具备停止条件的时候,一定要在循环体内给一个条件变化,否则就是一个死循环

                    }

             *     如果一个函数需要用到一个变量,那它会先在自己的作用域里去找这个变量。如果自己有那它就直接使用自己的,如果自己没有,那它就会一层一层往外找,直到找到外面的变量,找到后就用外面的变量

            var nul=null;

             *                 如果说想要在字符串里输入的引号与外在的引号相同,那就用转义字符(')

                        //说明现在传了三个参数,设置元素的属性值

             */

             *     不能转成Undefined 和Null

             *         2、数字        Number

            }

           4.关系运算符(对比)          

                        drive:true,

            

                    console.log('今天是星期一');

             /*

             */

            /*

                        var s6='It 's me';

            

十六、作用域

             */

             *                 break;    停止以下代码继续执行

             * 

            var a=10;

            console.log(isNaN(n1));        //false

             *     ===        首先先比较两个值的类型,如果说类型不同,那直接返回false

             * js中的数据类型

            };

            

             *         function 函数名(){}

             *                 把函数声明变成函数表达式的方法,在函数声明的前面加上  - ! ~ ()

            if(e>0){

             *     如果不确定先算谁,那就给要算的内容加上小括号,提高它的优先级.

                            console.log(n3);        //1.7976931348623157e 308

                                //类似与排除的意思

      

                        console.log(s5);        //It 's me

                        var s1='';

             *             false    假

             *     2、函数表达式

             * 语法

             *     case是可以累加的,有多个情况的话就可以放多个case

                console.log(i);     //0.1.2.4.

             *     三元操作符:操作的数据有三个
             *             a?b:c
             *     
             *      a作为一个条件

            

             * 注意:尽量避免使用全局变量,声明变量的时候一定要加var

 </script>

                    console.log('今天星期四');

             *         3、Number转字符串

                   getComputedStyle        获取计算后的样式集合

                    return result;   //需要的值要和return在同一行

            console.log(b===c);    //true

            

                        var u1=undefined;

            console.log(5%0);    //NaN             7%5        2

             *         1、Undefined转字符串

                        return getComputedStyle(arguments[0])[arguments[1]];

             *     Number(要转换的值)    把任意类型都转为数字

             * 

            })();

                        'girl-firend':null,

             *     停止循环,剩下的循环就不会走了(break后的代码是不会执行的)

                 * var c=1;

            console.log(isNaN(n));        //true

                console.log(result);   

             *                 数字最大值:Number.MAX_VALUE

             *             true    转字符串的结果为'true'

             *                 当这个值与变量的值相同的时候,才会走这里的代码

            var i=0;

             * 系统定义的数据类型                typeof返回的数据类型

             *     传进来的字符串必需是数字或者空格加数字开头,它会从数字开始,一位一位往后找,直到找到的字符不是数字就会停止,会把找到的数字字符转成真正的数字。如果没找到那就返回一个NaN

                                   f=10;         

                 

                    var nul=null;

                 * f=e 1;

             *     注意:局部变量与局部函数只能在声明它们的地方用,在其它的地方是用不到的

                alert('成立');

            console.log(String(b2));        //false

             *             }

      *      递增

     2.     document.onclick=function(){

             * 

             */

                        console.log(s1);        //a

             *         调用

             */

            var n2=NaN;

             *     2、隐式类型转换

             *             数字转数字的结果还为原来的数字

            var s2=' 100px';

             *             

            }

             *               - * /

                           (function fn5(){

            }

                    

             *                 break;    停止以下代码继续执行

                    alert(1);       //这里是弹不出,因为放在了return后面。

            if(n1<5&&n2<6){

             */

             *         return 值(值要和return在同一行)

             * arguments对象

             /*         4、未定义    Undefined

             *             false

                a ;//这个意思就是操作符在前面        //2

             *  !的意思是反

                            console.log(n1);        //12

                var c=1;

             *     这个集合中的每个数据都有一个自己对应的下标

            var n=12;

                console.log(c);    //2

             /*     二、复合(复杂)数据类型

                        console.log(u2);        //undefined        声明一个变量,但没给它赋值,那它就是undefined,

 

                    }            //获取box属性下height的值

             */

             /*

            console.log(Boolean(u));        //false

            var fn=function(){alert(1)}

             *         

               //形参不写,也不会影响实参

            console.log(typeof u);        //undefined

             */

             /*

             *     parseInt()        把字符串转成整数型数字

             */

                    };//其实写法是数组一样,最后一个是不需要逗号的

             *     

            var s5='0123';

                 *         ||    或者的意思

             *             键值对:key:value

             *     它具有一个功能是用来检测数字的,但是它的本意并不是用来检测数字的

            

                            //找到自己想要的东西就不走了。

                default:

           函数的typeof结果为function,但是js当中没有给函数定义一个类型

             /*         3、Boolean

             *         语法

                function fn4(){

五、检查数据是否是NaN ----isNaN

             * 

             *     x=x y

             *      放在后面,先把自己赋给另一个变量,自己再加1

             *             false转字符串的结果为'false'

            var s1='100px';

             *     把一种数据类型转换成另外一种数据类型

                                                  }

                    var u=undefined;

             *     isNaN()传进来的值,如果是一个数字的话,那它就返回一个false

            while(i<5){

             *  --放在前面,先把自己加个1然后赋给另一个变量,然后自己再减个1

                        //console.log(c);    //报错,因为只会往上面找

             *     检测一个数据的类型,返回这个类型对应的字符串(全小写)

            console.log(a==b);    //true

         变量戓者函数可访问的一个范围,以函数来划分,一个函数块就是一个作用域

                                           console.log(‘今天是星期三’);

六、运算符

 

            console.log(false-true);    //-1        减号的作用就是数学上的减法运算,会把两边都转成数字

            

                    }  

                           }

十五、函数内修改css  

十四、函数运算结果--return

                        var s3='';

             *             falae    转数字的结果为0

                        console.log(nul);    //null

                 a;  //这个意思就是操作符在后面

                     语法:   大括号{},里面的元素最后一个不需要加逗号,

             *                 当这个值与变量的值相同的时候,才会走这里的代码

             *             空字符串,空格字符串转数字的结果为0

             *             }

                        function fn6(){

                            console.log(n3*2);    //Infinity

            b =a;

                console.log('这是第二个函数声明');

             */

             *             function 函数名(参数){

             *             case 值:

                        language:['汉语','日语','英语']

             */

             *         1、Undefined转布尔值

            var b=10;

                //形参实际上是在函数里声明的变量,变量的初始值是undefined。在函数调用的时候,传实参的时候会把初始值给改了真实的值

             *     全局:整个文档

            

             * 

                        var b2=false;

                        var b2=false;

 

             *     代表了所有的实参集合(类数组)

                  console.log(attr,color[attr]);

             *         return 后面的代码是不会执行的

                console.log('这是第二个函数表达式');

style="font-size: 13pt; color: #080808; font-family: "consolas""> style="font-size: 13pt; color: #3e4b53; font-family: "consolas"">          style="color: #3e4b53; font-family: consolas; font-size: 13pt; line-height: 1.6">  < style="font-family: consolas; font-size: 13pt; line-height: 1.6; color: #2369b6">input  style="color: #cb2d01">type= style="color: #248c85">"text" id style="color: #38444b">= style="color: #248c85">"" value style="color: #38444b">= style="color: #248c85">""  style="color: #3e4b53; font-family: consolas; font-size: 13pt; line-height: 1.6">/>

            function fn3(){

             * 

             *     ==        比较的是两个值是否相同

             *         5、String转布尔值

             *         1、Undefined    

            console.log(true 1);        //2        加号两边没有字符中,那就是数学中的加法运算,会把true转成数字

             *     一、基本(简单)数据类型(有五种)

            console.log(Boolean(s3));    //true

            console.log(a===c);    //false

             * 

                    console.log(person['girl-firend']);        //null

            console.log(f);    //10

             *             把数字加上引号

            console.log(parseFloat(s4));        //100.256

             *                 当这个值与变量的值相同的时候,才会走这里的代码

             *     Boolean                            boolean

                console.log(name,age);

一、JS数据类型

             *     Null                                object

             * 查找规则

            var n1=10;

             *         字符串

                console.log('成立');

                        age:30,

             *         1、字符串    String

                        arguments[0].style[arguments[1]]=arguments[2];

            console.log(1 2);        //3

             *                 not a number

                    var o1=[];

                        name:'老王',//结束语不是;而是,

            console.log(parseInt(s3));        //NaN

             */

                    var result=0; 

            switch(n){

             *         对象        Object

                case 1:

             *     对象转成这三种数据是没有意义,因为对象里面可以放任意一种数据类型。

                console.log(d);    //1            

                    

             *         调用

                                    case   3:

            var b='10';

             * 

七、switch

             * 要做循环的时候,首先考虑for,如果for做不出来,那就选择用while

     5.逻辑运算符    (一般用作条件运算里面做判断)      

                        console.log(Number(s4));        //12

             *     while(条件语句){

             *             null

                            console.log(n4);        //5e-324

                    console.log(Number(nul));    //0

             *     判断一个值是不是NaN,它会先把参数用Number()方法转一下

             *             

             *     2、阻止函数继续运行

                weight:'90kg',

             * 

            var s2='';

             /* 

             *     1、形参

             *             1.由0-9之间的任意数字组合而成,可是整数也可以是小数。数字的范围在正无穷( Infinity)与负无穷(-Infinity)之间

                                  f=20;      

                        fn6();

                    

                var result=0;

                var btns=document.querySelectorAll("input[type=button]");

            person('kaivon',20);

                   var a=1;

                    

             *     --放在后面,先把自己赋给另一个变量,自己再减1

             *     返回的结果与系统当中定义的类型是有区别

                        var b1=true;

             *     }

             *         如果函数里没有return,那这个函数的返回结果就是undefined

                    console.log(Number(o2));        //NaN   对象为NaN

            add(12,37);

             *         2、Null转字符串

                                       调用的时候和数组不一样,数组是写对应的下标数,对象写的是对应的key

                

                };

             /*         5、空        Null

            var e=1;

            for(var i=0;i<5;i ){

             * for        次数循环

                        console.log(Number(s5));        //NaN

                }

                    //这个就是复合对象数据,可以自己定义这个对象里面的许多东西

             *     !==        只有当两个数据类型不同,值不同才会返回true

                function add(){

            

                        var s4='012';

             *     它是一个运算符

                        console.log(s2);        //kaivon

             *             有且只有一个值undefined

                

             *         形式上的参数,在函数声明的小括号里

              <input type="button" id="" value="按钮一" />

             *             注意:

                 * d=c;

          3. 赋值运算符(在前面的值的基础上与后面的值进行运算,并把得到的值重新赋给前面的值)

                        var s2=' ';

                

             *             true        真

            var n2=3;  

八、for in

             * 局部作用域

                        

             /*     

            console.log(typeof nul);        //object

                 *             &&    并且的意思

             *     如果a的值为真,返回b,否则返回c

                2.

                        var s4=' ';

      语法:

             *        第一种                typeof 数据        typeof u

             

             *   =的意思是在原有的基础上再加

             *         5、String转字符串

             }           这里的attr 所显示的是对应的下标数 0,1,2,3,4

             *         4、Boolean转布尔值

                            var n3=Number.MAX_VALUE;

         3.把类型转为字符串--就是在外面加多一个引号

             * 如果操作别人(有赋值给其它变量)

             *             Boolean()    明确将数据转成布尔值

            }

             *     String                            string

            

             */

            

                            }else{

            //null的typeof的结果是object,

            var a=1;

                }

                        //width                arguments[1]

                

                if(i==3){

            var person={

                        var s1='a';

             * 

                 */

            var b=2;

                        var b1=true;

            var d=20;

                }

            var n1=12;

             *     中括号、小括号、点属于同一级别,它们有最高的优先及

            }

                            console.log('a'-1);    //NaN

            console.log(isNaN(s));        //true

                     *       对象[属性名]            属性名对应的值

                    

             * isNaN()

                        //arguments[0]        box

                console.log(f);    //2

             *             'undefined'

      

                            var n1=12;

             *             case 值:

            var c='10';

       1.各种类型转成数字  

                }

                    continue;    //当循环到第3次的时候,这次的循环不会走,会跳到下一次的循环

             * 任意类型转布尔值

             *         数字

                        var s5="It 's me";

                    texts.value=add(123,25,7)    ;   //如果上面没有return,那么点击出现的是undefined

                        var s6='12*12';

            var s4='100.256rem247';

                    var o2={};

             * 任意类型转数字

            console.log(''-1);        //-1

             *     

             *                 引号是成对出现的

                        weight:'90kg',

             *             case 值:

             *     Boolean(要转换的值)

     以数组为例:

                        console.log(Number(s1));        //0

             *     取模的时候,如果前面的数字比后在的数字小,那得到的结果就是前面的数字

       2.1      

                /*

                console.log(e);    //2

             */

         以对象为例:

                    person.age=25;

             *         当条件满足的时候,会循环执行这里的代码

                        console.log(s6);        //It 's me

             *                 value    数据对应的值,这个值可以是简单数据类型也可以是复杂数据类型

                        var s5='12a';

                 */

            console.log(parseInt(s1));        //100

                    var person={

             *             转为对应的值

               /*

            }            这里attr会显示出所有属性名  name,age,height,weight

             *     1、返回函数的运算结果

             *             String()        明确将数据转成字符串

             *                 break;    停止以下代码继续执行

                 btns.onclick=function(){

 

            console.log(String(u));        //undefined

            console.log(Boolean(s1));    //true

            console.log(typeof o);        //object

            }

             *         6、Object转字符串

                console.log('documnet点击了');

           }

             *     取模的时候,后面的数字不能为0,如果为0的话得到的结果就是NaN

             * 

            

             *     x =y

            /*

             *     局部:函数范围

                        

             *             true        转数字的结果为1

            var nul=null;

                        var nul=null;

             */

 

             * 

             */

                            var n4=Number.MIN_VALUE;

            console.log(typeof fn);        //function

             *     parseFloat()        把字符串转成浮点型(小数)数字

             *             结果也是给对象加上引号

                        console.log(u1);        //undefined

             *     String(要转换的值)

            var num=12;

                name:'老王',

            

                console.log(css(box,'height'));   

             *         全局的作用范围是整个文档,在这个页面任何地方都可以访问到它们

             *         3、Number

             */

                            console.log(b);        //15

                var name='kaivon';

二、检车数据类型的方法---typeof

             */

                var d=c ;     //这里就是有赋值给别人

             *     --放在操作符的前面与后在都是一样的,让自己减1

                height:'180cm',

             * while    条件循环,它一般用在嵌套的元素,或者有嵌套的数据

             /*  放在前面,先把自己加个1然后赋给另一个变量,然后自己再加个1

               fn('这是一个函数声明');

                var age=2;

            var b=15;

       类似与

             *         如果说函数里有return,那这个函数的返回结果就是return后的值(运算后的结果)

             *         形参的值是由实参决定的

             */

                        height:'180cm',

                var e=1;

            fn2('这是一个函数表达式');

             *             如果说不是一个纯数字,那结果就是NaN

            var u=undefined;

             *         5、Number

             *             转数字的结果为NaN

            var s='kaivon';

             * 类型转换分为两种

 

              

            var n4=12;

             *             1、变量(参数)

            var s1='kaivon';

             *             结果就是本身

            console.log(Boolean(n1));    //false

             *             注意:函数表达式里的function后面如果有名字的话,在调用的时候是不能拿这个名字去调用

             *                 key    数据名称,它可以加引号也可以不加引号,当这个名字不符合变量命名规则的时候需要加上引号(数字除外),引号是成对出现的、

            var n3=Infinity;

            /*

                    }

             *       加、- 减、* 乘、/ 除、c 取模(求余数)、 、--

   一、全局作用域  

             *         变量或者函数在函数外面声明,那它们就是全局变量和全局函数

      1     * 算术运算符

            

          2.字符串转数字            

             *  

            if(a<12||b>20){

             * break

             *     循环,条件循环。只有当条件满足的情况下才会去循环

            var n1=0;

                 *         如果有一个条件成立的话,整个条件就成立

             * 任意类型转字符串------结果就是给对象加上引号

                           var n=3;

             *         第二种            typeof(数据)        typeof(u)

             *     从函数外面向里面传数据,在函数里可以接收到这些数据,并且能够使用它它。这些数据就叫参数

                        console.log(btn);    //null   因为还没有有写HTML

             *                 如果说字符串里面有引号,外在的引号一定要与里面的引号相反

     3.     //函数表达式的另一种调用方式

            //fn3('这是一个函数表达式');    //报错 注意:函数表达式里的function后面如果有名字的话,在调用的时候是不能拿这个名字去调用

 

            console.log(String(b1));        //true

            var s='kaivon';

               }

            

                    console.log(Number(o1));        //0   数组为0

                /*var name=undefined;

             *         语法

             *     

                    break;

             *             

                        //var s5='学辉";        //报错

                        console.log(b2);        //false

                console.log(i); // 0.1.2

             * --    递减

三、数据类型转换

            console.log(3%4);    //3               0%5        0

              //1 2*3=7           (1 2)*3=9     类似于数学运算

            console.log(Boolean(n3));    //true

             /*         2、Null

                    

            for(var attr in person){

             *     如果参数的结果为NaN,那它返回一个true

             *             有且只有一个值null

             *             字符串里的内容是不是一个纯数字,如果是个纯数字的话,就转成对应的数字

            var b1=true;

             * 函数参数

             * 把字符串转成数字

            console.log(typeof b);        //boolean

             *             空字符串转布尔值的结果为false,其它(包括空格字符串)的都转成true       

                        var btn=document.getElementById('btn');

            }

             *         通过一些方法,很明确的将某种数据类型转换为另一种数据类型

       * continue

            var s3='px100';

            }();        //函数表达式可以直接在后面加上一个小括号就能调用

                if(i==3){

            var fn4=function(){

             *     变量与函数的查找规则

             *         4、Boolean转字符串

             *         操作对象用的方法就是属性的方法

             * 

             *     Number                            number

                 *         如果当左边与右边的条件同时成立的时候,整个条件才成立

                        result =arguments[i];

                    if(arguments.length==2){

            !function fn5(){
                console.log('这是第二个函数声明');
            }();  这里的小括号是不能换行的

十、break与continue

             *         布尔值

                        console.log(Number(b1),Number(b2));    //1 0

             /*         3、布尔值    Boolean

             *         2、变量不用var声明,直接给变量赋值

             * 

            console.log(1 'a');        //1a

             *             Number()、parseInt()、parseFloat()        明确将数据转数字类型

             * 它俩可以放在操作数的前面,也可以放在操作数的后面

            console.log(true '1');    //true1    加号右边是字符串,那就是字符串连接的意思,会把true转成字符串true

                console.log(name);

                    break;    //从3开始以后的循环就不走了,breadk后面的代码也不会执行

             *             如果类型相同,如果值相等的话,返回true

                for(var i=0;i<arguments.length;i ){

             *         2、Null

                        console.log(b1);        //true

            function add(){

             *     Object                            object

                /*

             *     用来做判断的,根据一个变量的值,做不同的事情

            

                age:30,

            var o={left:10};

             * 

                    console.log(Number(u));        //NaN        

十三、arguments

                    result =arguments[i];

                case 2:

             * js支持把任意一种数据类型只能转换成以下三种类型

十七、作用域链

      二、局部作用域

            var e='20';

             *     这个集合还有一个length,代表了实参的个数

            /* b=b a*/

                            console.log(n2);        //23.56

             *     如果参数的结果不为NaN,那它返回一个false

             *                 当运算失败的时候会出现

             */

            var b=true;

            

             * typeof

                    function fn5(){

             *             default:

                    console.log('今天是星期二');

            var n=NaN;

                i ;

四、类型转换分类、

            fn3();

                        console.log(s4);        //空格字符串

            console.log(parseInt(s2));        //100

             *         var 变量

                  var color=['red','green','blue','yellow','pink'];

             *                 当以上变量都不满足的时候,会执行这里的代码

 

            

      1.     var fn2=function fn3(name){//这里的fn3是可以不写的。

十一、进一步理解函数---函数类型

             */

                        console.log(s3);        //什么都没有的字符串

             *     !=        比较的是两个值是不相同,如果两个值不相同的话返回true,相同的话返回false

            }

                    fn5();

                        console.log(Number(s3));        //NaN

            console.log(String(nul));    //null

                        var s3='kaivon';

            

                             };

             *             2.NaN

            console.log(Boolean(n2));    //false

            var f=e>0?10:20;

                css(box,'height','300px');

             /*

             *         在进行一些操作的时候,根本目的不是做类型转换。但是如果要进行操作的话,那数据必需符合某种类型。js会在内部对数据进行一些转换

             *         6、Object

                 * var e=1;

   

             *     声明局部作用域的方法

             *     Undefine                            undefined

            console.log(b);        //3

             * return  (函数内凡是有运算并且要输出这个运算结果的就用return)

             *         1、所变量或者函数放在函数外面声明

            

                a--;        //1

                                          break;  

     想取所有的值,数组可以用for也可以用for in ,但是对象只能用for in 

                         color[attr]显示的就是下标数对应的值。

            console.log(typeof n);        //number

       4.把各类型转为布尔值

                    if(arguments.length==3){

            console.log(Boolean(s2));    //false

                            var c=28;

                         这里的person[attr] 会显示所有属性名所对应的值。

本文由上海时时乐走势图发布于web前端,转载请注明出处:JavaScript自学笔记--基础部分上海时时乐走势图官

您可能还会对下面的文章感兴趣: