登录  /  注册
首页 > web前端 > js教程 > 正文

JavaScript比较冷门的知识点

巴扎黑
发布: 2017-07-22 15:24:59
原创
1022人浏览过

原生函数

  常用的原生函数

    String()

    Number()

    Boolean()

    Array()

    Object()

    Function()

    RegExp()

    Date()

    Error()

    Symbol()

  内部属性 [Class]

    所有typeof 返回值为object 的对象都包含一个内部属性[Class],这个属性无法直接访问,一般通过Object.prototype.toString(..) 来看。

      例如:

        Object.prototype.toString.call([1,2,3]);

          // "[object Array]"

    基本类型值

        Object.prototype.toString.call(null);

          // "[object Null]"

     封装对象包装

        由于基本类型值没有.length .toString() 这样的属性和方法。

    封装对象释疑

      想要自行封装基本类型值,可以使用Object(..)(不带new 关键字)

        var a = "abc";

        var b = new String(a);

        var c = Object(a);

          一般不推荐直接使用封装函数

    拆封

      封装对象中的基本类型值,可以使用valueOf() 函数。

        var a = new String("abc");

        var b = new Number(42);

        var c = new Boolean(true);

 

        a.valueOf(); // "abc"

        b.valueOf(); // 42

        c.valueOf(); // true

    原生函数作为构造函数

        Array(..)

        var a = new Array(1,2,3);

          a; // [1,2,3]

        var b = [1,2,3]

          b; // [1,2,3]

      构造函数Array(..),不要求必须带关键字new,不带时他会自动补上Array构造函数只带一个参数时候,该参数会被数组的预设长度而不是当数组中的一个元素。

        var a = new Array(3);

          a.length; // 3

          a;

        总之永远不要创建和使用空单元数组

    Object(..) , Function(..) , RegExp(..)

        除非万不得已,否则不要使用Object(..) / Function(..)/ RegExp(..)

 

    Date(..) Error(..)

      创建时间必须使用 new Date(),主要是用来获取当前的Unix 时间戳Date.new()然后通过日期对象中的getTime() 来获得。

 

     创建错误对象(error objec) 主要是为了获得当前运行的上下文。

    Symbol(..)

      基本数据类型——符号。符号具有唯一性的特殊值,用它来命名属性不容易导致重名。

      Symbol 的静态属性形式,Symbol.create, Symbol.iterator

         obj[Sybol.iterator] = function() {/*..*/}

        使用 Symbol(..) 原生构造函数来自定义符号,不能带new 关键字,否则报错。

          var mysym = Symbol("my own symbol");

            mysym; // Symbol(my own symbol)

            mysym.toString(); // "Symbol(my own symbol)"

            typeof mysym; // "symbol"

 

            var a = { };

            a[mysym] = "foobar";

            Object.getOwnPropertySymbols(a);

                // [Symbol(my own symbol)]

       原型类型

      原生构造函数有自己的 .prototype对象 如: Array.prototype,

        String.prototype.

        String#indexOf(..)

       在字符串中查找指定字符串的位置。

        String#charAt(..)

       获得字符串指定位置上字符

        String#substr(..),String#substring(..) String# slice(..)

      获取字符串的指定部分

        String#toUpperCase() String#toLowerCase()

      将字符串转换为大写和小写

        String#trim()

      去掉字符串前后的空格,返回新的字符串

 

    强制类型转换

      值的类型转换

          将值从一种类型转换为另一种类型转换,这是显示的情况,隐式的情况通常为强制类型转换。

          JavaScript 中的类型转换总是是返回标量基本类型。

      抽象值操作

        ToString

          抽象操作ToString ,它负责处理非字符串到字符串的强制类型转换数组的默认toString() 方法经过重新定义,将所有的单元字符串化以后在连接在一起。

            var a = [1,2,3];

            a.toString(); // "1,2,3"

        JSON字符串换,

          JSON.stringify(..) 在对象中遇到undefined,function symbol 时会自动将其忽略,在数组中则会返回null

            例如:

              JSON.stringify(undefined); // undefined

              JSON.stringify(function(){}); // undefined

              JSON.stringify(

                  [1,undefined,function(){},4]

                ); // "[1,null,null,4]"

              JSON.stringify(

                {a:2,b:function(){}}

              ); // "{"a":2}"

 

         toJSON() 返回的应该是一个适当的值,可以是任何类型,然后再由JSON.stringify(..) 对齐进行字符串化。

      ToNumber

        有时候需要将非数字值当做数字来使用,比如数学运算。

          true 转为 1false 转换为 0 ,undefined 转换为NaN

          null 转换为0

        为了将值转换为相应的基本类型,抽象操作ToPrimitive ,首先检查该值是否valueOf() 方法,如果有就用该值进行强制类型转换。没有就用toString()

        的返回值来进行强制类型转换。如果valueOf() toString() 均不会返回值就会产生TypeError 错误。

    ToBoolean

       假值:

        值可以被分为以下两类。

          1.可以被强制类型转换为false的值

          2.其他(被轻质类型转换为true的值)

        以下这些是假值

undefined

null

false

+0,-0NaN

""

        假值对象:浏览器在某些特定情况下,在常规JavaScript语法基础上创建了一些外来值,这些就是假值对象

      真值

        真值就是假值列表以外的值

 

      显式强制类型转换

        字符串和数字之间的显示转换

        字符串和数字之间显示强制类型转换是通过String(..) Number(..).

        两者之间的显式强制类型转换

var a = 42;

var b = String(a);

var c = "3.14";

var d = Number(c);

b; // "42"

d: // 3.14

         还有其它方式实现字符串和数字之间的显示转换

var a = 42;

var b = a.toString();

var c = "3.14";

var d = +c;

b; // "42"

d: // 3.14

    日期显示转换为数字

一元运算符+ 的另一个常见的用途是将日期对象(Date)对象强制转换为数字。

        var timestamp = +new Date();

    显式解析数字字符串

      解析字符串中的数字和将字符串强制类型转换为数字的返回结果都是数字。

        例如:

var a = "42";

var b = "42px";

Number(a); // 42

parseInt(a); // 42

Number(b); // NaN

parseInt(b); // 42

        解析允许字符串中含有非数字字符,解析按从左到右的顺序,如果遇到非数字字符就停止。

        parseInt(..) 针对的是字符串,像parseInt(..) 传递数字和其他类型的参数是没用的

    显示转换为布尔值

      ToBoolean 是显式的ToBoolean 强制类型转换:

var  a = "0";

var b = [];

var c = {};

 

var d = "";

var e = 0;

var f = null;

var g;

 

Boolean(a); // true

Boolean(b); // true

Boolean(c); // true

 

Boolea(d);  // false

Boolea(e);  // false

Boolea(f);  // false

Boolea(g);  // false

      一元运算符!显示地将值强制类型转换为布尔值。

var  a = "0";

var b = [];

var c = {};

 

var d = "";

var e = 0;

var f = null;

var g;

 

!!a;  // true

!!b;  // true

!!c;  // true

 

!!d; // false

!!e; // false

!!f; // false

!!g; // false

 

    隐式强制类型转换

      隐式地简化

        字符串和数字之间的隐式强制类型转换

        +运算符既能用于数字加法,也能用于字符串拼接。

var a = "42";

var b = "0";

var  c= 42;

var d = 0;

 

a + b; // "42"

c + d; // 42

        对象的 - 操作与 + 类似;

var  a =  [3];

var b = [1];

a - b ; // 2

      布尔值到数字的隐式强制类型转换

      隐式强制类型转换为布尔值

      下面的情况会发生隐式强制类型转换

1.if(..) 语句中的条件判断表达式。

2.for(..;...;..)语句中的条件判断表达式(第二个)

3.while(..) do..while(..) 循环中的条件判断表达式。

4.? : 中的条件表达式

5.逻辑运算符 || (逻辑或) (逻辑与) 左边的操作数(作为条件判断表达式)

      || &&

|| && 运算符 的返回值并不一定是布尔类型,而是两个操作数其中的一个的值

var a = 42;

var b = "abc";

var c = null;

 

a || b;  // 42

a && b; // "abc"

c || b; // "abc"

c&& b; // null

 

对于 || 来说 如果条件判断结果为true 就返回第一个数的值,如果为false 就返回第二个操作数。

&& 则相反。

下面是一个|| 十分常见的 || 用法。

function foo(a,b){

a = a || "hello";

b = b || "world";

console.log(a + " " + b );

}

 

foo(); // "hello world"

foo("yeah","yeah"); // "yeah yeah"

符号的强制类型转换

        宽松相等和严格相等

          “== 允许在相等比较中进行强制类型转换, 而=== 不允许

        抽象相等

          有几个非常规的需要注意

NaN 不等于NaN

+0 等于-0

  宽松不相等 != 就是==的相反, !== 同理

 

          字符串和数字之间的相等比较

1.如果Type(x) 是数字,Type(y)是字符串,则返回 x== ToNumber(y)

的结果。

2.如果Type(x) 是字符串,Type(y) 是数字,则返回 ToNumber(x)== y 的结果。

      其他类型和布尔类型之间的相等比较

              == 最容易出错的地方就是true false 与其他类型之间的相等比较

var  a = "42";

var b = true;

a == b; // false

1.如果Type(x) 是布尔类型,则返回ToNumber(x) == y 的结果

2.如果Type(y) 是布尔类型,则返回 x == ToNumber(y) 的结果

          首先:

var x = true;

var y = "42";

x == y;  // false

反过来

var x = "42";

var y = false;

x == y; // false

          null undefined 之间的相等比较

          null undefinded 之间的 ==  也涉及隐士强制类型转换。

1.如果 x null ,y undefined ,则结果为 true

2.如果x undefined, y null, 则结果为 true

 var  a == null;

var b;

a == b;  //  true

a == null; // true

b == null; // true

a == false; // false

b == false; // false

a == "" ; // false

b == ""; // false

a == 0; // false

b == 0; // false

 

      对象和非对象之间的相等比较

        关于对象和(对象/函数/ 数组) 和标量基本类型(字符串/数字/布尔值)之间的比较。

     1.如果Type(x) 是字符串或数字,type(y)是对象,则返回 x == ToPrimitive(y) 的结果

      2.如果Type(x) 是对象, Type(y)是字符串或数字,则返回

      ToPromitive(x) == y 的结果。

var a = 42;

var  b = [42];

a == b; // true

 

var a = "abc";

var b = Object(a);  // new String(a) 一样

a === b;  // false

a == b; // true

            a == b 结果为true,应为b 通过ToPromitive 进行强制类型转换,并返回基本类型值 “abc”,与 a 相等。

      假值相等的比较

        一下是常规和非常规的比较

"0" == null;     // false

"0" == undefined;  // false

"0" == false; // true  -- 晕!

“0” == NaN;  // false

"0" == 0; // true

"0" == "";   // false

 

false == null; // false

false == undefined; // false

false == NaN; // false

false == 0; // true   -- 晕!

false == ""  //  true   -- 晕!

false == []  //   true   -- 晕!

false == {}  // false

 

"" == null;  // false

"" == undefined; // false

"" == NaN; // false

"" == 0;  // true  -- 晕!

"" == []; // true  -- 晕!

"" == {}; // false

 

0 == null;  // false

0 == undefined; // false

0 == NaN;  // false

0 == []; true   -- 晕!

0 == {}; false

          因为他们属于假阳。

          极端情况

          [] == ![]  // true

         对布尔值进行强制类型转换 [] == ![] 变成 [] == false,

           2 == [2]

          "" == [null]; //true

 

42 == "43"      // false

"foo" == 42;     // false

"true" = '""        // false

 

42 == "42"      // true

"foo" == ["foo"]  // true

      安全运用隐式强制类型转换

1.如果两边的值中有true 或者 false, 千万不要使用 ==.

2.如果两边的之中有[],"" 或者 0 ,尽量千万不要使用==.这时候最好使用 === 来避免强制类型的转换。

 

      抽象关系比较

        双方都是字符串比较

var  a = ["42"];

var b = ["043"];

 

a

 a b 并没有被准换为数字,因为ToPrimitive 返回的是字符串,

比较的是 "42 " "043" 两个字符串, 因为"0"在字母顺序上小于

“4”,所以最后结果为 false.

      同理

var a = [4,2];

var b = [0,4,3];

a

a 被转为 “4,2”b 转为 “0,4,3” 同样式按字母顺序进行比较的。

var a = {b: 42};

var b = {b:43};

a

     a 是  [object  Object], b也是  [object  Object] 所以按着字母顺序

a 不成立。

    下面的例子

var a = {b: 42};

var b = {b:43};

a

a == b; // false

a > b; // false

a

a >= b; // true

以上就是JavaScript比较冷门的知识点的详细内容,更多请关注php中文网其它相关文章!

智能AI问答
PHP中文网智能助手能迅速回答你的编程问题,提供实时的代码和解决方案,帮助你解决各种难题。不仅如此,它还能提供编程资源和学习指导,帮助你快速提升编程技能。无论你是初学者还是专业人士,AI智能助手都能成为你的可靠助手,助力你在编程领域取得更大的成就。
来源:php中文网
本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系admin@php.cn
最新问题
热门教程
更多>
最新下载
更多>
网站特效
网站源码
网站素材
前端模板
关于我们 免责申明 意见反馈 讲师合作 广告合作 最新更新
php中文网:公益在线php培训,帮助PHP学习者快速成长!
关注服务号 技术交流群
PHP中文网订阅号
每天精选资源文章推送
PHP中文网APP
随时随地碎片化学习
PHP中文网抖音号
发现有趣的

Copyright 2014-2024 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号