简单介绍
javascript是html和css之间的粘合剂,是浏览器可以运行的变成语言
javascript代码放在html文件<script>标签中:
<script> 标签放在<head>标签中
<script>
js代码
</script>
或者有本地或远程js文件
<script src="style.js"></script>
基本语法
变量声明
var 变量名;//可以重复声明同名变量并覆盖
变量名=变量值;//变量赋值
let 变量名=变量值; //需要浏览器支持javascript 6及以上
使用let声明变量,同名变量只允许声明一次,不会发生同名变量覆盖问题
定义变量后最好必须给它赋值
const 常量名=常量值;//定义不可变变量,对象类型常量指向不可变,基本类型,常量值不可变
变量类型
javascript没有数据类型,所有变量都用var/let声明
可以是任意类型:数字,字符串,对象
定义好变量并赋值后可以使用
查看变量真实类型
typeof 变量名;//查看变量真实类型
- Number:正负整数/浮点数/科学计数(1e10)/八进制(010以0开头)/十六进制(0xffff)/+(-)Infinity/NaN
判断一个数是否为正整数:num > 0 && Number.isInteger(num)
javascript在底层以64bit的双精度浮点类型表示 :
所以会有精度问题:0.1+0.2不等于0.3
运算符
number运算符:
加+
减-
乘*
除/
取余%
自增++
自减--
字符串
可以用双引号或者单引号括起来的串
字符串操作符
+拼接
+=
s[index];//索引定位元素
s.concat(s1,s2..);//拼接多个字符串
s.toUpperCase();转大写
s.toLowerCase();转小写
s.replace(before, after);//替换字符串中的before为after字符串中的元素不能用索引方式定位修改
String.fromCharCode(parseInt(binArr[i], 2))//从二进制转换成10进制,然后根据10进制编码转换成字符串
String本质是字符数组,也可以使用下面数组的方法
数组
var daysOfWeek = [];//声明数组
var gradesInMaths = [12, 7, 14, 18, 9, 11];
可以下标访问 gradesInMaths[0];
数组长度:gradesInMaths.length;
添加元素:
直接使用没有元素的下标赋值:gradesInMaths[6]=100;
使用push:gradesInMaths.push(200)添加元素到数组最后
pop();移除并返回最后一个元素
shift();移除并返回第一个元素
unshift();添加元素到数组首部
splice(i,j);从索引i位置开始,移除j个元素
splice(i,j,e1,e2..)j后面的元素为在起始位置删除j个元素后插入的元素
slice(i,j)返回切片[i,j)
...arr数组的所有元素,需要用在函数参数或者[]包围使用
concat() 拼接两个数组,返回一个新数组 [...].concat([...]);
arr.indexOf(elem) 元素索引,-1没有找到
判断一个元素是否是数组:Array.isarray(elem);
[a, b] = [b, a]交换两个变量的值
[a,b,...arr]=[1,2,3,4,5,6] //a=1,b=2, arr=[3,4,5,6]
转义符
\
字符串和Number互相转换
字符串转Number:对字符串型Number进行运算,自动转换成Number:
方式一:
- var s = '1'; s = 3 * s; typeof s;
- "number"
方式二:
let num = parseInt("100");//解析转
number转字符串
number + "";//和字符串相加即转为字符串
object类型
使用{}
比如:var p = {givenName:'Michel', familyName: 'Buffa'};
访问属性:
可以使用p.givenName这样访问属性值
也可以使用p[属性名]
增加属性
p.newpropertie = value;
p[新属性名] = value;
删除属性:
delete p.givenName;
对象是否包含某属性:
object.hasOwnProperty(property);
对象的所有Key组成的数组
Object.keys(obj);返回obj对象的所有Key组成的数组
定义变量对象的内容也不能改变:
Object.freeze(变量名);
构造函数
function Dog(){
this.property = value;
}
使用构造函数新建一个对象实例:let newInstance = new Dog();
判断一个实例是否是通过构造函数构造的:
instance instanceof Dog;
使用prototype定义所有实例都相同的属性:
Dog.prototype.numLegs = 4;
Dog.prototype = {
constructor: Dog,//对象赋给 prototype会导致constructor属性被覆盖,需要显示重新定义
使用某个原型创建对象:
let duck = Object.create(Animal.prototype);
让子类继承父类的proto:
Duck.prototype = Object.create(Animal.prototype);
这样子类就可以使用父类中的方法;子类也可以自己特有的方法:
Duck.prototype.newProp = function(){};
遍历对象的所有属性:
for(let prop in instace){};
对象数组:
使用map遍历对象元素
可以根据传入map的函数作用在每个元素上,返回一个数组包含每个元素的返回值:
const result = users.map(user => ({user.name}));
返回每个对象的name元素数组。
filter()类似map,返回使传入的函数的结果为true的元素
reduce()迭代处理元素
arr.reduce((sum,item) => sum += item.age, 0);返回元素求和的值,第二个元素0是初始化返回值
返回对象:
const usersObj = users.reduce((obj, user) => {
obj[user.name] = user.age;
return obj;
}, {});
sort()排序数组
可以传入一个函数,函数返回0两个元素位置不变,返回> <0的大的往后
split(),按照指定的分隔符,返回字符串的字符串数组
const str = "Hello World";
const bySpace = str.split(" ");
str.split(/\W/) 正则表达式在//之间
基于首字母大写拆分:return str.trim().split(/(?=[A-Z])/);
join()是split反操作,将字符串数组通过指定的连接符转换成字符串
every();传入函数,返回boolean值,数组中的每个元素是否都让这个这个函数返回true
const numbers = [1, 5, 8, 0, 10, 11];
numbers.every(function(currentValue) {
return currentValue < 10;
});
some(),同every,作用是只要有元素满足函数中定义的条件,就返回true.
函数
定义函数function,如:
- function sum(a, b) {
- var c = a + b;
- return c;
- }
var othername=function functionName(parameters){};
调用的时候可以用函数变量名othername(parameters);
调用函数:
- var result = sum(1, 2);
函数中内置变量arguments包含函数的所有参数
function destroyer(arr) {
let newArr = arguments[0];
for (let i = 1; i < arguments.length; i++){
while(newArr.indexOf(arguments[i]) != -1){
newArr.splice(arr.indexOf(arguments[i]), 1);
}
}
return newArr;
}
可以立即执行的函数:(function(){...})();
console.log(变量)打印到控制台
条件判断
if (foo === undefined) {}
else{}
switch(variable){
case '***': statments;
break;
......
}
(boolean statment) ? statment1:statment2;
boolean表达式为ture执行表达式1,false执行表达式2;
逻辑运算符
&&(and)
||(or)
!(not)
非boolean值会隐式转换成Boolean值
false:
- undefined
- null
- 0
- NaN
- 空字符串
true:
false之外其他
比较运算符
- Equal == (类型转换后值相等就可以 1 == '1';是true)
- Not equal !=
- Greater than >
- Greater than or equal >=
- Less than <
- Less than or equal to <=
- Strict equal ===(必须值和类型完全一样)
- Strict not equal !==
- NaN == (===)NaN; false
- isNaN(expr) isNaN(NaN) true
循环
while(condition){}
do statment while(condition);
for(initialization;condition;incrementation){statment}
for(variable in expression){statment}
- var michel = { // michel is an object
- familyName:'Buffa', // familyName, givenName, age
- // are its properties
- givenName: 'Michel',
- age: 51
- }
- for(var property in michel) { // the for-in will
- // enumerate properties
- console.log(property); // will print "familyName",
- // "givenName",
- // "age"
- console.log(michel[property]); // michel['givenName'] same
- // as michel.givenName
- }
循环中也可使用break和continue
类
可以使用new新建一个对象实例
- function Hero(name, side) {
- this.name = name; // code outside of methods is usually for initializing
- this.side = side; // the properties. Very often, they match the parameters
- this.speak = function() {
- return "<p>My name is " + this.name +
- ", I'm with the " + this.side + ".</p>";
- }
- }
- var darkVador = new Hero("Dark Vador", "empire");
- var luke = new Hero("Luke Skywalker", "rebels");
- var ianSolo = new Hero("Ian Solo", "rebels");
- function makeHeroesSpeak() {
- document.body.innerHTML += darkVador.speak();
- document.body.innerHTML += luke.speak();
- document.body.innerHTML += ianSolo.speak();
- }
也可以这样:
- class Hero {
- constructor(name, side) {
- this.name = name; // property
- this.side = side; // property
- }
- speak() { // method, no more "function"
- return "<p>My name is " + this.name +
- ", I'm with the " + this.side + ".</p>";
- }
- }
- var darkVador = new Hero("Dark Vador", "empire");
函数在函数声明前掉用,类只能在类声明后调用
对象可以作为函数的返回值:
- function getMousePos(event, canvas) {
- var rect = canvas.getBoundingClientRect();
- var mxx = event.clientX - rect.left;
- var my = event.clientY - rect.top;
- return { // the getMousePos function returns an object. It’s a factory
- x: mx,
- y: my
- }
- }
静态属性和方法
类名.静态属性 定义静态属性,最好在类定义之后初始化
static 方法名 定义静态方法
- class Point {
- constructor(x, y) {
- this.x = x;
- this.y = y;
- // static property
- Point.nbPointsCreated++;
- }
- // static method
- static distance(a, b) {
- const dx = a.x - b.x;
- const dy = a.y - b.y;
- return Math.sqrt(dx*dx + dy*dy);
- }
- }
- // static property definition is necessarily outside of the class with ES6
- Point.nbPointsCreated=0;
对象类型变量放的是对象的地址,相当于指针;普通变量类型存放的是变量值。
比较两个对象变量时,只有两个变量指向同一个对象时它俩才真正相等。
_开头的变量是私有属性,需要使用getter和setter属性访问。get ***(){} set ***(){}
内置类
Array
parse***
var n = Number('3.1416');强制转化
var n = parseInt('3.1416'); // convert a string to an integer number
var n = parseFloat('3.1416'); // convert a string to a float number
Math
- Math.PI;
- 3.141592653589793
- > Math.SQRT2;
- 1.4142135623730951
- > Math.E; // Euler constant
- 2.718281828459045
- > Math.LN2; // Neperian log of 2
- 0.6931471805599453
- > Math.LN10; // Neperian log of 10
- 2.302585092994046
Math.random()返回0-1之间的随机数
Math.round(),四舍五入取整
Math.ceil(),取下限
Math.floor(),取上限
Math.pow(base,pow); base的pow次方
Math.sqrt(num); 开根号
Date
var date = new Date();
JSON
var jsonStr = JSON.stringify(obj); 将对象转化成json
var jsObj = JSON.parse(jsonStr); json转化成对象
注释
单行注释://
多行注释:/**/
共享模块代码导入导出
const uppercaseString = (string) => {
return string.toUpperCase();
}
const lowercaseString = (string) => {
return string.toLowerCase()
}
export {uppercaseString, lowercaseString};//导出要共享的函数,在其他文件中可以导入使用
import {uppercaseString} from "./***.js";//导入指定函数
import * as stringFunctions from './string_functions.js';//导入文件中的所有导出函数
stringFunctions.uppercaseString("hello");
stringFunctions.lowercaseString("WORLD!");
正则表达式
.test()测试一个字符串中是否包含指定字符串,返回true or false
let testStr = "freeCodeCamp";
let testRegex = /Code/;
testRegex.test(testStr);
/substring/ 严格匹配
/s1|s2|s3../ 匹配多个字符串中的一个即可
/s/i 忽略大小写匹配
.match()返回匹配到的字符串
testStr.match(testRegex);
/s/g 这样返回的所有匹配到的字符串,不加g的话只返回匹配到的一个字符串
.匹配任意一个字符
[c1c2c3...]只要匹配其中一个字符即可
[a-z]匹配范围内的任一字符
[^c1c2..]匹配不包含在中括号中的所有
c+:匹配指定字符一到多次
c*:匹配指定字符0到多次
默认是贪婪匹配,?是lazy模式
^s:匹配开头的s
s$ 匹配结尾的s
\w 字符数字下划线[a-zA-Z0-9_]
\W 除字符数字下划线外的其他
\d数字
\D非数字
\s空格
c{3,6} c重复3到6次
c? c可存在可不存在