JavaScript基础一
初识JavaScript
JavaScript的概念
JavaScript诞生于1995年，最早出现主要是用于处理网页中的前端验证，如用户名的长度、电话号码和邮箱等的格式。现在JavaScript主要是用于web开发的脚本语言。它是一门基于原型的解释型语言，支持面向对象、命令式和声明式风格。
实现
- ECMAScript
- DOM
- BOM
特点
- 解释型语言
解释型语言不需要编译成机器码，而是**直接执行**。解释型语言的运行较慢，
但使用了JIT技术使运行速度得到改善
- 类似于C和Java的语法结构
例如for、while、if、switch等语句和Java基本相似
- 动态语言
JavaScript语言中一切内容都使不确定的，就像变量的类型，可以改变
- 基于原型的面向对象
JavaScript的声明
第一种声明方式
<button onclick="alert('此为第一种JavaScript声明方式');">点我一下</button>
可以将JavaScript代码编写到标签的onclick属性种，但是这种写法属于结构与行为耦合，不变维护，不建议使用！
第二种声明方式
<a href="javascript:alert('第二种JavaScript声明方式');">你也点我一下</a>
<a href="javascript:;">你也点我一下</a>
可以将JavaScript代码编写到超链接标签的href属性中，当点击超链接时会执行JavaScript代码。如果不编写JavaScript代码则点击时没有任何效果。
第三种声明方式
<script type="text/javascript">
alert("第三种JavaScript声明方式");
</script>
可以将JavaScript代码书写到script标签中。type属性值默认为text/javascript，可以不写。
第四种声明方式
<script type="text/javascript" src="js/script.js"></script>
可以将JavaScript代码编写到外部JavaScript文件中，然后通过script标签引入。外部JavaScript文件可以在多个页面中使用，且利用的浏览器的缓存机制。这种声明方式常用于工具包的使用。**注意：**script标签一旦引入了外部JavaScript文件，则不能在其内部编写代码，需要重新创建一个新的script标签用于编写代码。
JavaScript的变量
变量的概念
在JavaScript中，我们使用变量来保存 字面量。通过JavaScript的特点可以知道变量的类型和值都是可以任意改变的。在JavaScript中我们使用var关键字来声明一个变量。
var a;
变量存储数据的六种数据类型
基本数据类型
- Number 数值类型
- String 字符串类型
- Boolean 布尔类型
- Null 空值类型
- Undefined 未定义类型
引用数据类型
- Object
数据类型之间的转换
强制类型转换
- 其他数据类型转换为String类型
var a = 123;
a = a.toString();//输出为 "123"
var b = null;
b = b.toString(); //报错
var c = undefined;
c = c.toString(); //报错
方式一：通过调用被转换数据的toString()方法，该方法会返回转换结果，不会影响原变量。
对于null和undefined没有toString()方法，如果调用则会报错。
var a = 123;
a = String(a);//输出为 "123"
var b = null;
b = String(b); //输出为 "null"
var c = undefined;
c = String(c); //输出为 "undefined"
方式二：将被转换数据作为参数传递给String()函数，该函数也会返回转换结果，不会影响原变量。
且会将null和undefined值直接转化为"null"和"undefined"。
- 其他数据类型转换为Number类型
var a = "123";
a = Number(a);//输出为 123
var b = true;
b = Number(b);//输出为 1
var c = false;
c = Number(c);// 输出为0
var d = null;
d = Number(d);// 输出为0
var e = undefined;
e = Number(e);// 输出为 NaN
方式一：将被转换数据作为参数传递给Number()函数，该函数也会返回转换结果，不会影响原变量。
字符串→数值
①若为纯数字字符串则直接转换为数字；
②若字符串中含有非数字内容则返回 NaN；
③若字符串全为空格或者空串则转换为0.
布尔→数值
①true 转换为 1
②false 转换为 0
null→数值 转换为 0
undefined→数值 转换为 NaN
var a = "123abc";
a = parseInt(a);//输出为 123
var b = "123.456px";
b = parseFloat(b);//输出为 123.456
var c = true;
c = parseInt(c);//输出为 1
方式二：
parseInt() 把一个字符串转换为一个整数。
parseFloat()把一个字符串转换为一个浮点数。
如果对非String使用parseInt()或parseFloat()，它会先将其转换为String然后在操作。
- 其他数据类型转换为Boolean类型
var a = 123;
a = Boolean(a);//true
var b = 0;
b = Boolean(b);//false
var c = "abc";
c = Boolean(c);//true
var d = "";
d = Boolean(d);//false
var e = null;
e = Boolean(e);//false
var f = null;
f = Boolean(f);//false
方式：将被转换数据作为参数传递给Boolean()函数，该函数也会返回转换结果，不会影响原变量。
数值→布尔 除0和NaN为false外其余全为true
字符串→布尔 除空串为false外其余权威true
null和undefined→布尔 都为false
隐式类型转换
var a = 123;
a = a + "";
console.log(typeof a);//String
首先我们要了解一个知识点：任何值和字符串相加都会转换为字符串，并做拼串操作。
将需要转换的数据和空串进行加法运算，即可将其转换为String类型。
此种转换由浏览器自动完成，实际上也是调用的String()函数。
var a = "123";
a = a - 0;
console.log(typeof a , a);//Number 123
var b = "123";
b = b * 1;
console.log(typeof b , b);//Number 123
var c = "123";
c = c * 1;
console.log(typeof c , c);//Number 123
在进行- * /运算时，任何值都会自动转换为Number。
其原理和Number()一样。
如何获取数据类型
var a = 123;
console.log(typeof a);//Number
console.log(typeof(typeof a));//String
在JavaScript中我们通过typeof来获取变量存储的数据类型，它会将该值的类型以字符串的形式返回。
JavaScript的运算符
算数运算符
算数运算符就是我们学习的加、减、乘、除、余，其基本用法与数学用法相似。
var a =123;
a = a + 1;
console.log(a);//124
var b = true;
b = b + 1;
console.log(b);//2
var c = "abc";
c = c + 123;
console.log(c);//"abc123"
var d = "abc";
d = d + true;
console.log(d);//"abctrue"
+可以对两个值进行加法运算，并将结果返回。
如果对两个字符串进行加法运算，则会做拼串处理，会将两个字符串拼接为一个字符串，并返回。
任何的值和字符串做加法运算，都会先转换为字符串，然后再和字符串做拼串的操作。
var a = 2;
a = a - true;
console.log(a);//1
var b = 2;
b = b * "2";
console.log(b);//4
var c = 2;
c = c / 2;
console.log(c);//1
var d = 3;
d = d % 2;
console.log(d);//1
- 可以对两个值进行减法运算，并将结果返回
* 可以对两个值进行乘法运算
/ 可以对两个值进行除法运算
% 取模运算（取余数）
一元运算符
一元运算符只含有一个操作数，常见的有"+“号和”-"号。
+正号不会对数字产生任何影响
-负号可以对数字进行负号的取反
var a = 123;
a = a + (+ "1");
console.log(a);//124
无论是+ - 在对于非Number类型值运算时，都会先将其转换为Number，然后再运算。
自增与自减
var a = 1;
var b = 3;
var n = a++;
console.log(a);//2
console.log(n);//1
n = ++a;
console.log(a);//3
console.log(n);//3
n = b--;
console.log(b);//2
console.log(n);//3
n = --b;
console.log(b);//1
console.log(n);//1
var c = 1;
console.log(c++);//1
var d = 1;
console.log(++d);//2
自增 ++
通过自增可以使变量在自身的基础上增加1
自增分成两种：后++(a++) 和 前++(++a)
无论是a++ 还是 ++a，都会立即使原变量的值自增1
不同的是a++ 和 ++a的值不同
a++的值等于自增前的值
++a的值等于自增后的值
自减 --
通过自减可以使变量在自身的基础上减1
自减分成两种：后--(a--) 和 前--(--a)
无论是a-- 还是 --a 都会立即使原变量的值自减1
不同的是a-- 和 --a的值不同
a-- 是变量自减前的值
--a 是变量自减以后的值
逻辑运算符
无论是哪一门汇编语言，逻辑运算符都是必不可少的，而JavaScript为我们提供了三种逻辑运算符。
逻辑与 &&
&&可以对符号两侧的值进行与运算并返回结果。
运算规则:两个值中只要有一个值为false就返回false，只有两个值都为true时，才会返回true。
var result = true && true;
console.log(result);//true
result = true && false;
console.log(result);//false
result = false && true;
console.log(result);//false
result = false && false;
console.log(result);//false
在JavaScript的与运算中
如果第一个值为true则直接返回第二个值
如果第一个值为false则不会检查第二个值，直接返回false
逻辑或 ||
||可以对符号两侧的值进行或运算并返回结果。
运算规则：两个值中只要有一个true，就返回true，如果两个值都为false，才返回false。
var result = true || true;
console.log(result);//true
result = true || false;
console.log(result);//true
result = false || true;
console.log(result);//true
result = false || false;
console.log(result);//false
JavaScript中或运算和与运算相反
如果第一个值为true则不会检查第二个值，直接返回true
如果第一个值为false则直接返回第二个值
逻辑非 ！
!可以用来对一个值进行非运算，所谓非运算就是值对一个布尔值进行取反操作，true变false，false变true。
var a = true;
a = !a;
console.log(a);//false
var b = 1;
b = !!b;
console.log(typeof b , b);//Boolean true
如果对非布尔值进行非运算，则会将其转换为布尔值，然后再取反。
利用该特点，可以将一个其他的数据类型进行两次非运算转换为布尔值。
相等运算符
相等运算符用来比较两个值是否相等，如果相等会返回true，否则返回false。
不相等用来判断两个值是否不相等，如果不相等返回true，否则返回false。
var a = "123"
var b = 123;
console.log(a == b);//true
console.log(a === b);//false
在使用 == 来做运算时，如果值得类型不同，则会自动进行类型转换，将其转换为相同类型值然后再进行比较。
在使用 === （全等）来做运算时，如果两个值得类型不同则直接返回false，它不会进行类型转换。
var a = "1";
console.log(a != "1");//false
console.log(a !== "1");//true
使用 != 来做运算时。它会对变量进行自动的类型转换，如果转换后相等它也会返回false。
使用 !== 来做运算时，它不会对变量进行自动的类型转化，如果两个值类型不同则直接返回true。
条件运算符
var a = 1;
var b = 2;
var max = a > b ? a : b;
console.log(max);//2
条件运算符也称三元运算符。
其语法为： 条件表达式?语句1:语句2;
在其执行时，首先对条件表达式进行判断，如果为true则执行语句1，为false则执行语句2。
流程控制语句
条件判断语句
使用条件判断语句可以在某个语句执行前进行判断，如果条件成立则执行该语句，若条件不成立则语句不执行。
if语句的三种语法：
语法一：
if(条件表达式){
语句...
}
语法二：
if(条件表达式){
语句...
}else{
语句...
}
语法三：
if(条件表达式){
语句...
}else if(条件表达式){
语句...
}else if(条件表达式){
语句...
}else{
语句...
}
//语法一
var a = 1;
if(a > 0){
console.log(a);//1
}
//语法二
var b = 0;
if(b > a){
console.log(b+"大");
}else{
console.log(b+"小");//b小
}
//语法三
var c = 1;
if(c > a){
console.log(c+"大");
}else if(c < a){
console.log(c+"小");
}else{
console.log(c + "=" + a);//c=a
}
条件分支语句
条件分支语句也叫做switch语句
语法：
switch(条件表达式){
case 表达式:
语句...
break;
case 表达式:
语句...
break;
default:
语句...
break;
}
执行流程：
在执行switch语句时，它会依次将case后的表达式的值和switch后的表达式的值进行全等比较，
如果比较结果为true则从当前case开始执行以下所有代码，我们可以在每一个case语句的最后添加一个break关键字，这样可以确保只会执行当前case后的语句，而不会执行其他的case。
如果比较结果为false，则继续向下比较。
如果所有的比较结果都为false，则只执行default后的语句。
var a = 3;
witch(a){
case 1:
console.log("语句一");
break;
case 2:
console.log("贰语句二");
break;
case 3:
console.log("语句三");//语句三
break;//退出switch语句
default:
console.log("非法数字~~");
break;
}
循环语句
通过循环语句可以反复的执行一段代码多次，在JavaScript中为我们提供了三种循环语句：while循环、do…while循环和for循环。
while循环
语法：
while(条件表达式){
语句...
}
执行流程：
先对条件表达式进行求值判断，
如果值为true，则执行循环语句，循环语句执行完毕以后，继续对表达式进行判断；
如果为true，则继续执行循环语句，以此类推；
如果值为false，则终止循环。
var a = 1;
while(true){
alert(a++);//警告框依次弹出123456789
//判断a是否是10
if(a == 10){
//退出循环
break;
}
}
do…while循环
语法：
语法：
do{
语句...
}while(条件表达式)
执行流程：
do...while语句在执行时，会先执行循环语句，
循环语句执行完毕以后，再对while后的条件表达式进行判断，
如果结果为true，则继续执行循环语句，执行完毕继续判断以此类推。
如果结果为false，则终止循环。
var a = 1;
do{
console.log(a);//输出一次 1
}while(a < 1);
for循环
语法：
for(初始化表达式;条件表达式;更新表达式){
语句...
}
执行流程：
第一步：执行初始化表达式，（初始化表达式只会执行一次）
第二步：执行条件表达式，返回判断结果
如果为true，则执行循环
如果为false，终止循环
第三步：执行更新表达式
当更新表达式执行完后，继续重复执行第二步和第三步。
for(var i = 0 ; i < 10 ; i++ ){
alert(i);//警告框一次弹出1-10
}
注意：
for循环中的三个部分都可以省略，如果在for循环中不写任何的表达式，只写两个;此时循环是一个死循环会一直执行下去。
//能不用就不用
for(;;){
alert("hello");
}
案例
水仙花数
for(var i=100 ; i<1000 ; i++){
var b = parseInt(i/100);
var s = parseInt((i-bai*100)/10);
var g = i % 10;
if(b*b*b + s*s*s + g*g*g == i){
console.log(i);// 153 370 371 407
}
}
九九乘法表
for(var i=1 ; i<=9 ; i++ ){
for(var j=1 ; j<=i ; j++){
document.write(j+"*"+i+"="+i*j);
}
document.write("<br />");
}
质数
for(var i=2 ; i<=100 ; i++){
//创建一个布尔值，用来保存结果，默认i是质数
var flag = true;
//判断i是否是质数
//获取到2-i之间的所有的数
for(var j=2 ; j<i ; j++){
//判断i是否能被j整除
if(i%j == 0){
//如果进入判断则证明i不是质数,修改flag值为false
flag = false;
}
}
//如果是质数，则打印i的值
if(flag){
console.log(i);
}
}
442
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
