javascript 基础语法整理

2018-08-04 11:18:08

局部变量:在函数中通过 var 声明的变量。
全局变量:在函数外通过 var 声明的变量。没有声明就使用的变量(不管是在函数内部还是外部),默认为全局变量。在浏览器里,全局变量或者函数都是 window 的成员。

javascript 里没有块概念,也就是说在普通的判断,循环块里声明的变量都为全局变量。

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

if(1){
    var a = 1;
}
console.log(a);  //1
console.log(window.a);  //1

//下面是等同
test();
window.test();

void(0)、javascript:void(0)、void(a+1),void 关键字里会执行,但是不会返回。

先使用变量后声明叫做变量提升,函数则叫做函数提升。

//在body体插入html
<script>
document.write("<h1>这是一个标题</h1>");
</script>

//引入外部js
<script src="myScript.js"></script>

//日志
console.log()

变量

var name='dailei',age=22;
var name='dailei',
age=22;

var car;                //undefined
car = null;             //清空变量

var car = "bei";
var car;                //值还在

字符串

var name = new String("1234")       //不推荐,速度慢
var name = "1234";
console.log(name[1]);  //2
console.log(name.length);

//replace() 替换与正则表达式匹配的子串
var aaa = "abcd 1234 dandan";
aaa = aaa.replace('1234', 'dailei');     //abcd dailei dandan


//split() 把字符串分割为子字符串数组
var aaa = "i am a good wife";
var arr = aaa.split(" ");     //["i", "am", "a", "good", "wife"]

//substr() 从起始索引号提取字符串中指定数目的字符
var aaa = "i am a good wife"
var sub = aaa.substr(7, 9);    //good wife


//substring() 提取字符串中两个指定的索引号之间的字符
var aaa = "i am a good wife"
var sub = aaa.substring(7, 16);  //good wife
var sub = aaa.substring(7);      //第2个参数省略,就是截取到末尾

name = name.trim();  //移除字符串两边的空白

数组

var arr = ["car", 2, 3]
var arr = []
var arr = new Array();
var arr = new Array("1", "2");
arr[0] = "dailei";

//连接数组
var arr3 = arr.concat(arr2,arr3);

var a = [1,2,3];
var b = a.concat(4,5);


//数组合并成字符串,默认用逗号隔开
arr.join();
//手动指定
arr.join('.');


arr.pop()           //删除并返回最后面元素
arr.shift()         //删除第一个元素并返回

arr.push("James");      //在末尾压入一个或多个元素并返回长度
arr.unshift("James");      //在开头插入一个或多个元素并返回长度

arr.reverse();                      //反转数组
arr.slice(start,end);               //截取并返回数组
arr.splice(index,howmany,item1)     //删除元素后并插入新元素,返回被删除的项目的数组

arr.sort(func);                 //排序

arr.toString();         //返回逗号隔开的字符串

条件循环

if(1){
    
}else if(2){
    
}else{
    
}

switch(1){
    case 1:x=1;
        break;
    case 2:
        x=2;
        break;
    default:
        cccc;
}

var person={fname:"John",lname:"Doe",age:25}; 

for (x in abcd){        //x为属性名
    str = str + abcd[x];
}

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

//里面可以省略
var i = 0;
for (;;){
    if(i<5){
        console.log(i);
        i++;
    }else{
        break;
    }
}

正则表达式

i 执行对大小写不敏感的匹配。
g 执行全局匹配(查找所有匹配而非在找到第一个匹配后停止)。
m 执行多行匹配。

// search 返回第一个匹配的索引位置
// 匹配失败返回-1

var re = /\d+/;
var str = "aaa1 2 3 4";

var n = str.search(re);
var i = str.search("2 3");

//3 5
console.log(n,i);
// match 可以捕获,返回数组,索引0代表全匹配
// 索引1代表第一个子匹配

var re = /www\.(\w+)\.(com)/g;
var str = "www.freecls.com";
var arr = str.match(re);

console.log(arr);  //["www.freecls.com", "freecls", "com"]

异常

try {
  //在这里运行代码
} catch(err) {
  //在这里处理错误
}

throw "error"       //手动报错

json

JSON.parse()	  //用于将一个json字符串转换为对象。
JSON.stringify()  //用于将对象转换为json字符串。

对象

javascript 里面有一句话,一切事物都是对象,当然不是完全正确,但是普通的数据类型比如整数,字符串,javascript 内部都帮助我们实现了一些东西,才导致普通的字符串可以有类似对象使用方法。

//不是对象
var str = "123";

#但是使用的时候临时当做对象
console.log(str.length);
var person = {name:"dailei", age:22}

var person={
firstname : "John",
lastname  : "Doe",
id        :  5566
};

var name = person.lastname;
var name = person["lastname"];

var aaa = "lastname";
person.aaa      //错误
person[aaa]     //正确
//对象创建
function Demo(){
    var obj=new Object();
    obj.name="张思";
    obj.age=12;
    obj.firstF=function(){
        console.log(111);
    }
    obj.secondF=function(){
        console.log(222);
    }
    return obj;
}

var one=Demo();

//使用 new 方法创建。
function Demo(){
    this.name="张思";
    this.age=12;
    this.firstF=function(){
    }
    this.secondF=function(){
    }
}

var one=new Demo;


函数

函数严格来说是个对象,有属性和方法。

函数无法设置默认参数,没有传递的参数为undefined。

//函数声明
function aa(){};
var xx = function(){};      //匿名函数
//var myFunc = new Function("a", "b", "return a*b");   不推荐
//匿名自调用函数
(function () {
    var x = "Hello!!";
})();

myFunc.toString();  //把函数作为字符串返回如
//auguments对象包含了参数的数组
function(){
    var len = arguments.length;      //参数个数
    var ar1 = arguments[0];          //第一个参数
}

传递函数对象时其实传递的是引用。

var myFunc = function(a, b){
    return a * b;
};

myFunc.age = 22;

function test(obj){
    obj.age=23;
}

console.log(myFunc.age);
test(myFunc);
console.log(myFunc.age);
//this代表调用函数的那个对象
var myFunc = function(a, b) {
    this.aaa = a;
    this.bbb = b;
};
myFunc(3,4);                    //window.aaa=3,window.bbb=4

var x = new myFunc(1,2);        //对象x.aaa=1,x.bbb=2
console.log(myFunc);            //函数
//函数作为对象方法
var myObject = {
    firstName:"John",
    lastName: "Doe",
    fullName: function () {
        return this.firstName + " " + this.lastName;
    }
}
myObject.fullName();         // 返回 "John Doe"


闭包

闭包 closure 就是能够读取其他函数内部变量的函数。

局部变量只有在该局部变量的作用域里才能读取到。

在本质上,闭包就是将函数内部和函数外部连接起来的一座桥梁。

善用闭包,由于外部已经链接到内部局部变量,导致内部的资源无法及时释放。

function f1(){
    var n=999;
    
    nAdd=function(){n+=1};      //全局匿名
    
    function f2(){
        alert(n);
    }
    
    return f2;
}

var result=f1();

result(); // 999
nAdd();
result(); // 1000

下面的例子 object.getNameFunc() 函数调用返回了一个函数对象,然后再利用()调用,其实是在外部环境调用,所以调用者为 windows,那么 this 代表的就是 windows 对象。

var name = "The Window";

var object = {
    name : "My Object",
    getNameFunc : function(){
        return function(){
            return this.name;
            };
    }
};
alert(object.getNameFunc()());      //The Window
var name = "The Window";

var object = {
    name : "My Object",
    getNameFunc : function(){  //这个函数是由 object 调用的,所以this为 object.
        var that = this;       //赋值给局部变量 that。
        return function(){
            return that.name;
            };
    }
};

alert(object.getNameFunc()());  // My Object


©著作权归作者所有
收藏
推荐阅读
简介
天降大任于斯人也,必先苦其心志。