JavaScript

<script>
  // 在这里写你的JS代码
</script>

<script src="myscript.js"></script>

// 单行注释
/*多
  行
  注
  释*/

var a = ‘jack‘;

1、alert(要输出的内容): 在浏览器中弹出一个框，在框中有我们要输出的内容（不管最后输出什么内容，输出的都是字符串内容）

2、confirm：在浏览器中弹出一个提示确认框（confirm("确定要删除吗?")）

3、console.log(要输出的内容); 按F12在控制台中的console页卡中显示（一般用于调试，不会影响页面中的内容）

4、console.dir：他只是比.log输出的内容更加详细一些

5、console.table：他能把我们需要查看的数据在控制台中以一个表格的形式展示出来

6、document.write(我们要输出的内容); 直接显示在页面中，不停的输出

7、innerHTML/innerText 动态的向指定的元素中添加内容

var a = true
var b = false

var a = [123, "ABC"];
console.log(a[1]);  // 输出"ABC"

var a = [10, 20, 30, 40];
for (var i=0;i<a.length;i++) {
  console.log(a[i]);
}
/* 10
   20
   30
   40*/

var arr = [‘a‘, ‘b‘, ‘c‘]
console.log(arr.length);   // 3

arr.length = 5  
console.log(arr)     // ["a", "b", "c", undefined,undefined] 数组组的值和长度发生改变
console.log(arr.length)  // 5

// 通过索引改值
var arr = [‘a‘, ‘b‘, ‘c‘]
arr[2] = ‘C‘
console.log(arr)    // ["a", "b", "C"]


// 索引超过了范围
var arr = [‘a‘, ‘b‘, ‘c‘]
arr[5] = ‘d‘
console.log(arr)    // ["a", "b", "c",undefined, undefined, "d"]

arr = [‘b‘, ‘c‘, ‘d‘, ‘a‘]
arr.sort()  // ["a", "b", "c", "d"]

function sortNumber(a,b){
    return a - b
}
var arr1 = [11, 100, 22, 55, 33, 44]
arr1.sort(sortNumber)  // [11, 22, 33, 44, 55, 100]

arr1 = [‘a‘,‘b‘,‘c‘]
arr2 = [‘1‘,‘2‘,‘3‘]
ret = arr1.concat(arr2)
ret   // ["a", "b", "c", "1", "2", "3"]

arr = [‘a‘, ‘b‘, ‘c‘, ‘d‘];
arr.join(‘-‘);   // "a-b-c-d"

// 删除元素 两个参数
arr = [‘a‘, ‘b‘, ‘c‘, ‘d‘]
ret = arr.splice(0,2)  // 从索引为0的项开始删,删除两个.
console.log(ret)  // [‘a‘, ‘b‘]
console.log(arr)  // [‘c‘. ‘d‘]

// 替换元素 三个参数
arr = [‘a‘, ‘b‘, ‘c‘, ‘d‘]
ret = arr.splice(1,2,‘B‘,‘C‘,‘D‘)  // 从索引为1的项开始删,删除两个后再从删除的位置添加三项‘B‘,‘C‘,‘D‘
console.log(ret)   //  ["b", "c"]
console.log(arr)   //  ["a", "B", "C", "D", "d"]

//  插入元素 三个参数
arr = [‘a‘, ‘b‘, ‘c‘, ‘d‘]
ret = arr.splice(3,0,‘B‘,‘C‘)  // 从索引为3的项开始删,删除0个后,从索引为3的位置添加两项‘B‘,‘C‘
console.log(ret)   // []
console.log(arr)   // ["a", "b", "c", "B", "C", "d"]

false == 0      // true
false === 0    // false

NaN === NaN;   // false
isNaN(NaN);    // true

1/3 ===(1-2/3);   // false
1.1 + 2.2   // 3.3000000000000003   存在误差

(1-2/3) - 1/3 < 0.0000001   // true

var a = 10;
if (a > 5){
  console.log("yes");
}else {
  console.log("no");
}

var a = 10;
if (a > 5){
  console.log("a > 5");
}else if (a < 5) {
  console.log("a < 5");
}else {
  console.log("a = 5");
}

var day = new Date().getDay();   // 获取星期几
switch (day) {
  case 0:   // 若day为0则执行case 0 : 下面的语句
  console.log("Sunday");
  break;    // 跳出
  case 1:   // 若day为1则执行case 1 : 下面的语句
  console.log("Monday");
  break;
default:   // 不满足case 0 和case 1 条件时执行
  console.log("...")
}

var a = 1;
var b = 2;
var c = a > b ? a : b   // 判断a是否大于b, a>b则c=a, 否则c=b  最后返回c

for (var i=0;i<10;i++) {
  console.log(i);
}

var x = 0;
for (;;) { // 将无限循环下去
    console.log(‘无限循环‘)
}


var x = 0;
for (;;) { // 将无限循环下去
    if (x > 10) {
        break; // 通过if判断来退出循环
    }
    x ++;
}

var dic = {
    name: ‘Jack‘,
    age: 20,
    city: ‘Beijing‘
};
for (var key in dic) {
    console.log(key); 
}
/* name
   age
   city */

var i = 0;
while (i < 10) {
  console.log(i);
  i++;
}

var n = 0;
do {
    n = n + 1;
} while (n < 10);
n; // 10

/* 普通函数定义 
  function 指出这是一个函数定义, 
 f1是函数名,
 ()内可以写参数
 {}内是函数体 */
function f1() {
  console.log("Hello world!");
}

// 带参数的函数
function f2(a, b) {
  console.log(arguments);  // 内置的arguments对象
  console.log(arguments.length);
  console.log(a, b);
}

// 带返回值的函数
function sum(a, b){
  return a + b;
}
sum(1, 2);  // 调用函数

// 匿名函数方式
var sum = function(a, b){
  return a + b;
}
sum(1, 2);

// 立即执行函数
(function(a, b){
  return a + b;
})(1, 2);

// 没有参数的函数
function f1(){
    console.log(‘hello,world‘)
}
f1()   // hello,world
//有参数的函数
function f2(num1,num2){
    return num1
}
f2(5)   // 5 传入的参数比定义的少也没有问题

function add(a,b){
  console.log(a+b);   // 3
  console.log(arguments.length)   // 3
}

add(1,2,3)

// 局部变量：

在JavaScript函数内部声明的变量（使用 var）是局部变量，所以只能在函数内部访问它（该变量的作用域是函数内部）。只要函数运行完毕，本地变量就会被删除。

// 全局变量：

在函数外声明的变量是全局变量，网页上的所有脚本和函数都能访问它。

// 变量生存周期：

JavaScript变量的生命期从它们被声明的时间开始。

局部变量会在函数运行以后被删除。

全局变量会在页面关闭后被删除。

var age = 18;
function foo(){
  console.log(age);
  var age = 22;
  console.log(age);
}
foo();  
// 22



var age = 18;
function foo(){
  console.log(age);
  var age = 22;
  console.log(age);
  function age(){
    console.log("呵呵");
  }
  console.log(age);
}
foo();  
// 22
// 22

var a = {"name": "jack", "age": 18};
console.log(a.name);
console.log(a["age"]);

var person=new Object();  // 创建一个person对象
person.name="Alex";  // person对象的name属性
person.age=18;  // person对象的age属性

//方法1：不指定参数
var d1 = new Date();
console.log(d1.toLocaleString());
//方法2：参数为日期字符串
var d2 = new Date("2004/3/20 11:12");
console.log(d2.toLocaleString());
var d3 = new Date("04/03/20 11:12");
console.log(d3.toLocaleString());
//方法3：参数为毫秒数
var d3 = new Date(5000);
console.log(d3.toLocaleString());
console.log(d3.toUTCString());

//方法4：参数为年月日小时分钟秒毫秒
var d4 = new Date(2004,2,20,11,12,0,300);
console.log(d4.toLocaleString());  //毫秒并不直接显示

var d = new Date(); 
//getDate()                 获取日
//getDay ()                 获取星期
//getMonth ()               获取月（0-11）
//getFullYear ()            获取完整年份
//getYear ()                获取年
//getHours ()               获取小时
//getMinutes ()             获取分钟
//getSeconds ()             获取秒
//getMilliseconds ()        获取毫秒
//getTime ()                返回累计毫秒数(从1970/1/1午夜)

var str1 = ‘{"name": "jack‘", "age": 18}‘;
var obj1 = {"name": "jack", "age": 18};
// JSON字符串转换成对象
var obj = JSON.parse(str1); 
// 对象转换成JSON字符串
var str = JSON.stringify(obj1);

//RegExp对象

//创建正则对象方式1
// 参数1 正则表达式(不能有空格)
// 参数2 匹配模式：常用g(全局匹配;找到所有匹配，而不是在第一个匹配后停止)和i(忽略大小写)

// 用户名只能是英文字母、数字和_，并且首字母必须是英文字母。长度最短不能少于6位 最长不能超过12位。

// 创建RegExp对象方式（逗号后面不要加空格）
var reg1 = new RegExp("^[a-zA-Z][a-zA-Z0-9_]{5,11}$");

// 匹配响应的字符串
var s1 = "bc123";

//RegExp对象的test方法，测试一个字符串是否符合对应的正则规则，返回值是true或false。
reg1.test(s1);  // true

// 创建方式2
// /填写正则表达式/匹配模式（逗号后面不要加空格）
var reg2 = /^[a-zA-Z][a-zA-Z0-9_]{5,11}$/;

reg2.test(s1);  // true


// String对象与正则结合的4个方法
var s2 = "hello world";

s2.match(/o/g);         // ["o", "o"]             查找字符串中 符合正则 的内容
s2.search(/h/g);        // 0                      查找字符串中符合正则表达式的内容位置
s2.split(/o/g);         // ["hell", " w", "rld"]  按照正则表达式对字符串进行切割
s2.replace(/o/g, "s");  // "hells wsrld"          对字符串按照正则进行替换

// 关于匹配模式：g和i的简单示例
var s1 = "name:jack Age:18";

s1.replace(/j/, "哈哈哈");      // "name:哈哈哈ack Age:18"
s1.replace(/a/g, "哈哈哈");     // "n哈哈哈me:j哈哈哈ck Age:18"      全局匹配
s1.replace(/a/gi, "哈哈哈");    // "n哈哈哈me:j哈哈哈ck 哈哈哈ge:18"  不区分大小写


// 注意事项1：
// 如果regExpObject带有全局标志g，test()函数不是从字符串的开头开始查找，而是从属性regExpObject.lastIndex所指定的索引处开始查找。
// 该属性值默认为0，所以第一次仍然是从字符串的开头查找。
// 当找到一个匹配时，test()函数会将regExpObject.lastIndex的值改为字符串中本次匹配内容的最后一个字符的下一个索引位置。
// 当再次执行test()函数时，将会从该索引位置处开始查找，从而找到下一个匹配。
// 因此，当我们使用test()函数执行了一次匹配之后，如果想要重新使用test()函数从头开始查找，则需要手动将regExpObject.lastIndex的值重置为 0。
// 如果test()函数再也找不到可以匹配的文本时，该函数会自动把regExpObject.lastIndex属性重置为 0。

var reg3 = /foo/g;
// 此时 regex.lastIndex=0
reg3.test(‘foo‘); // 返回true
// 此时 regex.lastIndex=3
reg3.test(‘xxxfoo‘); // 还是返回true
// 所以我们在使用test()方法校验一个字符串是否完全匹配时，一定要加上^和$符号。

// 注意事项2(说出来你可能不信系列)：
// 当我们不加参数调用RegExpObj.test()方法时, 相当于执行RegExpObj.test("undefined"), 并且/undefined/.test()默认返回true。
var reg4 = /^undefined$/;
reg4.test(); // 返回true
reg4.test(undefined); // 返回true
reg4.test("undefined"); // 返回true

abs(x)      返回数的绝对值。
exp(x)      返回 e 的指数。
floor(x)    对数进行下舍入。
log(x)      返回数的自然对数（底为e）。
max(x,y)    返回 x 和 y 中的最高值。
min(x,y)    返回 x 和 y 中的最低值。
pow(x,y)    返回 x 的 y 次幂。
random()    返回 0 ~ 1 之间的随机数。
round(x)    把数四舍五入为最接近的整数。
sin(x)      返回数的正弦。
sqrt(x)     返回数的平方根。
tan(x)      返回角的正切。