javapython区别最全整理_Javascript常用知识整理（附与java,python的异同）持续更新ing...

说实话&＃xff0c;再你熟悉了C C&＃43;&＃43; java python后再学js&＃xff0c;总是会有无数错觉&＃xff0c;总觉得它的语法像什么&＃xff0c;又不太像。作为动态语言又没python那么简洁&＃xff0c;里面很多语法借鉴了c和java的那套&＃xff0c;但是又不像c那么严格。js是弱类型语言&＃xff0c;而且还是有一些动态语言的灵活性在里面。

题记

如果带着之前学C&＃43;&＃43;/java的思路去学js&＃xff0c;总觉得十分别扭&＃xff0c;特别是它的object和function&＃xff0c;真是让人摸不着头脑。

所以说啊&＃xff0c;js真是个磨人的小妖精。要征服这个小妖精还真不是一时半会能实现的&＃xff0c;所以&＃xff0c;还是慢慢来吧&＃xff0c;把征服它的过程都记录一下。

注意&＃xff1a;本文是一个本人的总结记录文&＃xff0c;并不是一个js教程&＃xff0c;请不要抱着《从入门到精通》的思路来看本文。如果你有一定的编程基础&＃xff0c;或者正在学习js&＃xff0c;这个笔记可能对你有点用。(以下笔记是廖雪峰Javascript教程&＃xff0c;还有freecodecamp教程笔记)

对了&＃xff0c;本文持续更新ing....

6-20更新&＃xff1a;

ES6规范中引入了Map和Set

map创建mapvar m &＃61; new Map([[&＃39;Michael&＃39;, 95], [&＃39;Bob&＃39;, 75], [&＃39;Tracy&＃39;, 85]]);

m.get(&＃39;Michael&＃39;); // 95Map具有以下方法&＃xff1a;(set get has delete)var m &＃61; new Map(); // 空Map

m.set(&＃39;Adam&＃39;, 67); // 添加新的key-value

m.set(&＃39;Bob&＃39;, 59);m.has(&＃39;Adam&＃39;); // 是否存在key &＃39;Adam&＃39;:truem.get(&＃39;Adam&＃39;); // 67m.delete(&＃39;Adam&＃39;); // 删除key &＃39;Adam&＃39; 如果删除失败返回falsem.get(&＃39;Adam&＃39;); // undefined

由于一个key只能对应一个value&＃xff0c;所以&＃xff0c;多次对一个key放入value&＃xff0c;后面的值会把前面的值冲掉&＃xff1a;var m &＃61; new Map();

m.set(&＃39;Adam&＃39;, 67);

m.set(&＃39;Adam&＃39;, 88);

m.get(&＃39;Adam&＃39;); // 88

set

Set和Map类似&＃xff0c;也是一组key的集合&＃xff0c;但不存储value。由于key不能重复&＃xff0c;所以&＃xff0c;在Set中&＃xff0c;没有重复的key。

要创建一个Set&＃xff0c;需要提供一个Array作为输入&＃xff0c;或者直接创建一个&＃96;空var s1 &＃61; new Set(); // 空Setvar s2 &＃61; new Set([1, 2, 3]); // 含1, 2, 3重复元素在Set中自动被过滤&＃xff1a;var s &＃61; new Set([1, 2, 3, 3, &＃39;3&＃39;]);

s; // Set {1, 2, 3, "3"}

注意数字3和字符串&＃39;3&＃39;是不同的元素。add(key)方法

可以添加元素到Set中&＃xff0c;可以重复添加&＃xff0c;但不会有效果&＃xff1a;>>> s.add(4)>>> s

{1, 2, 3, 4}>>> s.add(4)>>> s

{1, 2, 3, 4}delete(key)方法

可以删除元素&＃xff1a;var s &＃61; new Set([1, 2, 3]);

s; // Set {1, 2, 3}s.delete(3);

s; // Set {1, 2}

5-26更新&＃xff1a;

字符串转正则eval()

有人可能发现了&＃xff0c;js的正则表达式并不是字符串&＃xff0c;但是实际使用中&＃xff0c;我们经常需要字符串去构造正则表达式&＃xff0c;这个时候就可以用eval()去转化。eval()可以用来解析字符串

但是eval是一个很危险的操作&＃xff0c;如果非必要&＃xff0c;尽量少使用var test &＃61; &＃39;this is a test&＃39;;var exp &＃61; &＃39;/\w/ig&＃39;;

test.match(eval(exp));

数组的splice函数array.splice(start, deleteCount[, item1[, item2[, ...]]])

js提供了一个splice函数&＃xff0c;用来删除index位置处的deleteCount数目的元素&＃xff0c;并且在index处加入item1,2,3……&＃xff08;可以不加入&＃xff09;

这个函数可以用来替换数组内的部分元素var myFish &＃61; [&＃39;angel&＃39;, &＃39;clown&＃39;, &＃39;mandarin&＃39;, &＃39;surgeon&＃39;];

// removes 0 elements from index 2, and inserts &＃39;drum&＃39;var removed &＃61; myFish.splice(2, 0, &＃39;drum&＃39;);

// myFish is [&＃39;angel&＃39;, &＃39;clown&＃39;, &＃39;drum&＃39;, &＃39;mandarin&＃39;, &＃39;surgeon&＃39;]

// removed is [], no elements removed

removed &＃61; myFish.splice(3, 1);

// myFish is [&＃39;angel&＃39;, &＃39;clown&＃39;, &＃39;drum&＃39;, &＃39;surgeon&＃39;]

// removed is [&＃39;mandarin&＃39;]

removed &＃61; myFish.splice(2, 1, &＃39;trumpet&＃39;);

// myFish is [&＃39;angel&＃39;, &＃39;clown&＃39;, &＃39;trumpet&＃39;, &＃39;surgeon&＃39;]

// removed is [&＃39;drum&＃39;]

数组的slice函数arr.slice([begin[, end]])

取出数组的从begin到end的元素&＃xff0c;重新组成数组。var fruits &＃61; [&＃39;Banana&＃39;, &＃39;Orange&＃39;, &＃39;Lemon&＃39;, &＃39;Apple&＃39;, &＃39;Mango&＃39;];var citrus &＃61; fruits.slice(1, 3);// [&＃39;Orange&＃39;,&＃39;Lemon&＃39;]

5-25更新&＃xff1a;

字符串的slice()和substr()和substring()str.slice(beginSlice[, endSlice])

str.substr(start[, length])

str.substring(indexStart[, indexEnd])

都是截断函数&＃xff0c;但是有一些区别slice和substr能接负数&＃xff0c;代表倒数。substring不行

substr第二参数代表长度不是end

substring的end如果大于start会自动交换&＃xff0c;slice不会,会返回""

三者均支持越界var str &＃61; "example";console.log(str.slice(-3)); // "ple" console.log(str.substr(-3)); // "ple" console.log(str.substr(2,4)); // "ampl" console.log(str.substring(2,4)); // "am" console.log(str.slice(4,2)); // "" console.log(str.substring(4,2)); // "am" console.log(str.slice(2,-1)); // "ampl" console.log(str.substring(0,100)); // "example" console.log(str.slice(0,100)); // "example" console.log(str.substr(0,100)); // "example"

for in vs for of (ES6新加)

js中也有for in用法&＃xff0c;但是和python有些不一样的地方。js中的for in对数组也是返回的是键&＃xff0c;比如“0”&＃xff0c;“1”……(而且由于历史遗留问题&＃xff0c;&＃39;name&＃39;也在遍历范围内)

python中直接返回的是数组中的值

js中的for of和python中的for in才是真实对应的哦~不仅可以用于数组也可以用于字符串

所以for in用在json中的遍历比较合适。

比如说你如果需要遍历数组&＃xff0c;你可以使用普通for循环做&＃xff0c;也可以用for of。var arr &＃61; ["a","b","c","d"];for(var i &＃61; 0;i < arr.length;i&＃43;&＃43;&＃xff09;

{  console.log(arr[i]);

}for(var i in arr&＃xff09;

{ //这里的i是字符串&＃xff0c;打印出来可以发现是“0”&＃xff0c;“1”&＃xff0c;“2”……

console.log(arr[i]);

}for(var i of arr&＃xff09;

{  console.log(i);

}

forEach

更好的方式是直接使用iterable&＃xff0c;内置的forEach方法&＃xff0c;它接收一个函数&＃xff0c;每次迭代就自动回调该函数。以Array为例&＃xff1a;var a &＃61; [&＃39;A&＃39;, &＃39;B&＃39;, &＃39;C&＃39;];

a.forEach(function (element, index, array) {

// element: 指向当前元素的值 // index: 指向当前索引 // array: 指向Array对象本身 alert(element);

});

注意&＃xff0c;forEach()方法是ES5.1标准引入的&＃xff0c;你需要测试浏览器是否支持。

Set与Array类似&＃xff0c;但Set没有索引&＃xff0c;因此回调函数的前两个参数都是元素本身&＃xff1a;var s &＃61; new Set([&＃39;A&＃39;, &＃39;B&＃39;, &＃39;C&＃39;]);

s.forEach(function (element, sameElement, set) {

alert(element);

});

Map的回调函数参数依次为value、key和map本身&＃xff1a;var m &＃61; new Map([[1, &＃39;x&＃39;], [2, &＃39;y&＃39;], [3, &＃39;z&＃39;]]);

m.forEach(function (value, key, map) {

alert(value);

});

如果对某些参数不感兴趣&＃xff0c;由于Javascript的函数调用不要求参数必须一致&＃xff0c;因此可以忽略它们。例如&＃xff0c;只需要获得Array的element&＃xff1a;var a &＃61; [&＃39;A&＃39;, &＃39;B&＃39;, &＃39;C&＃39;];

a.forEach(function (element) {

alert(element);

});

5-23更新&＃xff1a;

语法

目前大多语言都是类C的&＃xff0c;js也一样&＃xff08;除了python ruby这些自成一派的&＃xff09;区分大小写

字符串可以用&＃39;&＃39;或“”和python一样

变量不区分类型&＃xff0c;和python一样&＃xff08;python不用写var&＃xff09;

每条语句结尾可以省略分号

注释与C,C&＃43;&＃43;,java,php相同

代码段要封闭与C,C&＃43;&＃43;,java同&＃xff08;和python不一样&＃xff09;

运算符完全和C一致&＃xff0c;有自加自减&＃xff0c;有逗号表达式&＃xff0c;有条件运算符&＃xff01;&＃xff01;&＃xff08;和python不一样&＃xff09;

逻辑运算符&＃xff0c;条件&＃xff0c;循环语句和C一致&＃xff08;和python不一样&＃xff09;

有switch-case语句&＃xff08;和python不一样&＃xff09;

数组

js的数组和python的list一样可以存不同类型不同维度个数据&＃xff0c;除了可以用下标查看修改数据外&＃xff0c;还有几个方法&＃xff1a;push()&＃xff1a;加到最后

pop():  从最后取

shift(): 从开头取

unshift(): 加入开头

构造数组的方式还有如下&＃xff1a;&＃xff08;除了特别说明的外&＃xff0c;都不改变原数组&＃xff09;

用map创建数组var oldArray &＃61; [1,2,3,4]var timesFour &＃61; oldArray.map(function(val){  return val * 4;

});

用reduce压缩数组

reduce的第2个参数&＃xff08;初始值&＃xff09;可选&＃xff0c;如果没有&＃xff0c;就从数组第一个开始var array &＃61; [4,5,6,7,8];var sum &＃61; 0;

sum &＃61; array.reduce(function(pre,cur){    return pre&＃43;cur;

},0);

用fliter过滤数组

如果我们只需要数组中小于6的元素var oldArray &＃61; [1,2,3,4,5,6,7,8,9,10];var newArray &＃61; oldArray.fliter(function(val){  return val < 6;

});

数组排序sort

数组有排序的功能(会改变原数组&＃xff0c;并且也会返回)&＃xff0c;如果不带参数&＃xff0c;默认是按字符串排序&＃xff0c;如果要改变排序方式&＃xff0c;可以在里面增加比较函数&＃xff0c;规则如下负数&＃xff1a;a在b前

大于&＃xff1a;b在a前var array &＃61; [1, 12, 21, 2];//降序排序array.sort(function(a,b){   return  b-a;

});//升序排序array.sort(function(a,b){   return  a-b;

});

逆转数组reverse

改变原数组var array &＃61; [1,2,3,4,5,6,7];array.reverse();

数组拼接concatvar oldArray &＃61; [1,2,3];var newArray &＃61; [];var concatMe &＃61; [4,5,6];

newArray &＃61; oldArray.concat(concatMe);

字符串和数组转换用split切割字符串var string &＃61; "Split me into an array";

var array &＃61; [];array &＃61; string.split(&＃39; &＃39;);用joint把数组拼接成字符串var joinMe &＃61; ["Split","me","into","an","array"];var joinedString &＃61; &＃39;&＃39;;

joinedString &＃61; joinMe.join(&＃39; &＃39;);

范围

在function之外的是全局变量&＃xff0c;否则是局部变量

注意&＃xff1a;如果没加var 默认是全局变量&＃xff01;// Declare your variable herevar myGlobal&＃61; 10;function fun1() {  // Assign 5 to oopsGlobal Here

oopsGlobal &＃61; 5;

}// Only change code above this linefunction fun2() {  var output &＃61; "";  if (typeof myGlobal !&＃61; "undefined") {

output &＃43;&＃61; "myGlobal: " &＃43; myGlobal;

}  if (typeof oopsGlobal !&＃61; "undefined") {

output &＃43;&＃61; " oopsGlobal: " &＃43; oopsGlobal;

}  console.log(output);

}

输出console.log()

严格相等

严格相等&＃xff08;&＃61;&＃61;&＃61;&＃xff09;不仅比较值&＃xff0c;还比较类型

因为在js中&＃xff0c;7 &＃61;&＃61; “7”

undefined

js中有undefined&＃xff0c;当一个变量没定义的时候&＃xff0c;可以用下面方法判断if(typeof(value)&＃61;&＃61;"undefined"){

alert("undefined");

}

number

Javascript不区分整数和浮点数&＃xff0c;统一用Number表示&＃xff0c;以下都是合法的Number类型&＃xff1a;123; // 整数1230.456; // 浮点数0.4561.2345e3; // 科学计数法表示1.2345x1000&＃xff0c;等同于1234.5-99; // 负数NaN; // NaN表示Not a Number&＃xff0c;当无法计算结果时用NaN表示Infinity; // Infinity表示无限大&＃xff0c;当数值超过了Javascript的Number所能表示的最大值时&＃xff0c;就表示为Infinity

注意NaN

这个特殊的Number与所有其他值都不相等&＃xff0c;包括它自己&＃xff1a;NaN &＃61;&＃61;&＃61; NaN; // false

唯一能判断NaN

的方法是通过isNaN()函数&＃xff1a;

isNaN(NaN); // true

随机数

js中的随机数是用Math.random()生成的&＃xff0c;同样&＃xff0c;也是返回(0,1)&＃xff0c;如果要某个范围&＃xff0c;可以用下面的方法Math.floor(Math.random() * (ourMax - ourMin &＃43; 1)) &＃43; ourMin;

正则

js的正则是用的//&＃xff0c;很庆辛的发现和vim很像&＃xff0c;比如查找"in"可以用下面的正则&＃xff1a;var testString &＃61; "How many non-space characters are there in this sentence?";

var expression &＃61; /in/gi;

var incount&＃61; testString.match(expression).length;

“/ /”包含的是正则内容

g 是全局

i 表示忽略大小写

正则表达式都差不多&＃xff0c;基本和python一致

除了 * . &＃43;

\d表示数字

\D表示非数字

\s表示空格

\S表示非空格

\w表示字符[0-9a-zA-Z_]&＃xff08;特别注意有个_&＃xff09;

\W表示非字符

Object 和 json

js中的object数据结构就类似其他语言中的map&＃xff0c;hashmap&＃xff0c;是一个键值对应的结构。Javascript Object notation(JSON)其实也就是指在js中使用的这种数据交换的类型。

访问的方式一般有两种"." 如果是单纯的数字或者没空格的字符串&＃xff0c;可以用

"[]" 带空格的就要用"[]"了。

举例&＃xff1a;var ourDog &＃61; {  "name": "Camper",  "legs": 4,  "tails": 1,  "friends": ["everything!"]

};var name &＃61; ourDog.name;

name &＃61; ourDog["name"];var prop&＃61; "name";

name &＃61; ourDog[prop];

&＃96;

你可以用Array或object嵌套var myStorage &＃61; {      "car": {        "inside": {          "glove box": ["maps","phone"],          "passenger seat": "crumbs"

},        "outside": {          "trunk": "jack"

}

}

};

// get maps

var gloveBoxContents &＃61; myStorage.car.inside["glove box"][0];

如果要删除一个属性&＃xff0c;用deletedelete ourDog.tails;

如果增加属性&＃xff0c;直接使用"."和"[]"就好了&＃xff0c;和python差不多

如果要看某个属性存在不存在 hasOwnProperty()&＃xff1a;myObj.hasOwnProperty("top");

由于object的属性和map很像&＃xff0c;因此你可以用它来做查表操作&＃xff1a;var alpha &＃61; {      1:"Z",      2:"Y",      3:"X",      4:"W",

...      24:"C",      25:"B",      26:"A"

};

alpha[2]; // "Y"

alpha[24]; // "C"

面向对象

js的面向对象可能是最“直观”而又诡异的。

js可以直接用之前说的方式直接声明一个Object对象var car &＃61; {      "wheels":4,      "engines":1,      "seats":5

};

也可以用构造函数的方法&＃xff1a;var Car &＃61; function() {      this.wheels &＃61; 4;      this.engines &＃61; 1;      this.seats &＃61; 1;

};

创建实例直接用new就行了&＃xff0c;然后创建的实例可以直接添加新的属性。var Car &＃61; function() {  this.wheels &＃61; 4;  this.engines &＃61; 1;  this.seats &＃61; 1;

};var myCar &＃61; new Car();

myCar.nickname &＃61; "coolcar";

私有变量&＃xff0c;还记得var吗&＃xff1f;如果在类中用var就是局部变量了&＃xff0c;也就意味着是私有变量了。如果不使用var&＃xff0c;在js中默认是全局变量var Car &＃61; function() {      // this is a private variable

var speed &＃61; 10;

// these are public methods

this.accelerate &＃61; function(change) {

speed &＃43;&＃61; change;

};

this.decelerate &＃61; function() {

speed -&＃61; 5;

};

this.getSpeed &＃61; function() {        return speed;

};

};

为了避免大家因为忘记使用var而导致变量变成全局的这一缺陷&＃xff0c;所有的Javascript代码都应该使用strict模式。我们在后面编写的Javascript代码将全部采用strict模式。就是在所有的js程序前加上use strict

作者&＃xff1a;voidsky_很有趣儿

链接&＃xff1a;https://www.jianshu.com/p/c3500f476973