转换为false值

这些值都可以被转化为 false

undefined, NaN, 0, "", null, false
NaN => Not a Number  //类型是Number

&&运算符

a && b

a, b 可以是一个表达式, 数字, 字符串….

运算的时候, 先看 a 的布尔值转换是否为 true :

如果为真, 去看 b 的值, 并且返回,

如果为假, 返回 a 的值.

a && b &&c => (a && b) && c 按照上述过程进行判断

应用

(布尔表达式) && 要执行的语句

如果布尔表达式为真, 就执行语句

|| 运算符

与&&类似, &&似乎是希望从表达式中找的一个假的值, 然后返回, 找遍了整个表达式, 没有找到假的值, 就返回真的值.

||是从所有的表达式中找到一个真的值返回, 如果没有找到, 就返回假的值.

综上所诉, && 遇到假就停止, ||运算符遇到真就停止.

! 运算符

将后面的表达式转换成布尔值再取反.

! 123 = ! true = false;

!! 就是转换成布尔值 !!null = false

`prompt`

JavaScript的输入

var data = parseInt(window.prompt());

类型转换

parseInt(test,radix);
//radix 告诉 js 引擎, test 是什么进制的, 转化的结果是 10进制数
    // 如果不传入 radix, 将把某个东西解析成整型数字
    // 例如: parseInt("123.3akjd") => 123
    // 其规则是: 从前往后看, 碰到非数字截止, 如果一开始就是非数字, 解析失败, 为NaN

parseFloat();
String();
xxx.toString();  //undefined null不能调用
Boolean();
Number();
var

正则表达式

//正则表达式的两种创建方式
var reg = //;   //这是一个基本的 reg 表达式的格式
var reg = new RegExp('');

//语法规则
[]      //  一个方括号代表一位
[abc]   //  匹配[]里面的任意一个字符
[0-9A-z]//  
[^a]    //  这一位不能是a, 找给定集合之外的字符
/(abc|bcd|cde)/     //查找任何指定的选项。

元字符

\w      // [0-9A-z_]
\W      // [^/w]
\d      // [0-9]
\D      // [^\d]
\s      // [\t\v\r\v\f] 匹配空白字符
\S      // [\s]
\b      // 单词边界
\B      // 非单词边界 
.       // [^\r\n]  查找单个字符，除了换行和行结束符。
\uxxxx  //查找以十六进制数 xxxx 规定的 Unicode 字符。
[\w\W]  // 这种类似的表达式能匹配所有东西

匹配修饰符

var reg = //i;  忽略大小写(ignoreCase)
var reg = //m;  多行匹配(multiline)
var reg = //g;  全局匹配(global), 找到的匹配项全部返回
var reg = //img;

测试方法

reg.test(str);  //找到str中符合reg语义的匹配项
reg.exec(str);  //
    如果 reg 是全局匹配, exec 的返回值是这样的
        ["匹配到的字符串", index:被匹配到的字符串第一个字母的索引, input:"str"];
        每执行一次 exec, 就会在当前 index, 向后匹配, 如果匹配成功, 修改index, 返回如上的类数组
        匹配到字符串尾端之后:
        [null, index:被匹配到的字符串第一个字母的索引, input:"str"];
    如果 reg 不是全局匹配, exec的返回值是这样的:
        ["匹配到的字符串", index:被匹配到的字符串第一个字母的索引, input:"str"]; (没什么变化)
        但是不管执行多少次, 都只是第一次匹配成功的样子
str.match(reg); //返回str中符合reg语义的所有匹配项, 以数组的形式返回

量词

n+      // {1, }    一个或多个
n*      // {0, }    零个或多个
n?      // {0,1}
n{x}    // {x}      x个
n{x,y}  // {x,y}    x-y个
n{x, }  // {x, }    x个以上
^       //以...开头
$       //以...结尾
/\1\2/  // \1称为反向引用, 引用第一个匹配上的字符, 如\w\1 如果\w匹配到的是a, 这个表达式会匹配aa
            //即第二个a是引用的第一个匹配上的a, \2当然就是指匹配上的第二个字符
//用了反向引用的表达式, 使用exec方***多出几个值, 这几个值就是匹配上的字符
/a(?=b)/    // a 后面是否紧跟着 b? b 不参与选择, 只参与修饰, 结果里面没有 b
/a(?!b)/    // a 后面紧跟着的不是 b 的 a
    
/a{1}/  //只能匹配一个 a
/a{2}/  //匹配两个连续的 a
/a{n}/  //匹配 n 个连续的 a
/a{m, n}/   //匹配连续的 m 到 n 个 a   如果有 n 个 a, 那么就不会只匹配 m 个, 正则匹配是贪婪匹配
/a{1,}/     //匹配一个或多个 a

取消贪婪匹配

//正则匹配是贪婪的, 能匹配多的时候, 绝对不会匹配少的
//我们可以通过在表达式后面添加"?"来取消贪婪匹配
a{n, }?;     //如果匹配成功,  将会是一个 n 个 a 的字符串
a*?;        // ""
a+?;        // "a"
a?          // 等同于 a{0,1}

string方法

str.match(reg);
str.search(reg);
str.split(reg);
str.replace("a", "b");  //特别注意: repalce只能匹配到一个a替换成b,没有全局匹配能力

正则实例

// the-first-name, 通过正则匹配, 字符串替换方法, 将其改为小驼峰式
var reg = /-(\w)/g;
var str = "the-first-name";
str.relace(reg, function($, $1){
   return $1.toUpperCase(); 
});


var str = "100000000000";
var reg = /(\B)(?=(\d{3})+$)/g;
str = str.replace(reg, ',');    //"100,000,000,000"

js的一些小基础， 很小