百万年薪python之路 -- JS基础介绍及数据类型

JS代码的引入

方式1:
    <script>
        alert('兽人永不为奴!')

    </script>
方式2:外部文件引入
    src属性值为js文件路径
    <script src="test.js"></script>

变量声明

变量名是区分大小写的。
推荐使用驼峰式命名规则。首字母大写
保留字不能用做变量名。
声明前要加var关键字.
var a = 1;

加var定义的变量是全局变量,在函数里定义会是局部变量
不加定义的变量不管在哪,都是全局变量

数据类型

数值类型(number)

示例:
    var a = 1;
    var b = 1.1;
    var c = 123e5;  // 12300000  e5  *10的5次方
    var d = 123e-5;  // 0.00123
    typeof a; --- number
    typeof b; --- number

字符串(string)

var a = '努力';
    typeof a; --- "string"
字符串 转换成 数值类型
parseInt:
    var a = '111';
    var b = parseInt(a);
    typeof b; --- "number"
parseFloat:
    var a = '1.11';
    var b = parseFloat(a);

var a = 'bbbb1';
var b = parseInt(a);
    b = NaN  NaN是not a number
    typeof b; --- number类型  NaN和NaN不相等
字符串相关方法
字符串拼接
    var a = "Hello"
    var b = "world"
    var c = a + b;
    console.log(c); --- Helloworld

.length 查看字符串长度
    示例:
        var c = 'hello';
        c.length; -- 5
.trim()  移除两端空格,得到一个新值,不会改变原来的值
    示例:
        var a = '   hello   ';
        var  b = a.trim();
.trimLeft()
.trimRight()

.charAt(n)  找到索引为n的字符
var c = b.charAt(1);

.concat()  字符串拼接
    示例:
        var a = 'nihao';
        var b = 'girls';
        var c = a.concat(b);

.indexOf() 查看元素的索引
    示例:
        var a = c.indexOf('a');
        var a = c.indexOf('i',3);  参数3的意思是从索引3的位置开始往后找,找到就返回对应的索引值,找不到就返回-1
.slice() 切片
    示例:
        var c = "nihaogirls";
        var a = c.slice(0,5); -- 'nihao'

.toLowerCase() #全部变小写
.toUpperCase()  #全部变大写
    示例:
        var c = "nihaogirls";
        var a = c.toUpperCase();
.split() 字符串切割
    示例:
        var c = "nihaogirls";
        var a = c.split('g',1);  'g'是切割条件,1是切割后,返回结果的数量

布尔值

var a = true;
var b = false;
数据类型都有布尔属性:
    ""(空字符串)、0、null、undefined、NaN都是false。

null和undefined

null表示值是空,一般在需要指定或清空一个变量时才会使用,如 name=null;

undefined表示当声明一个变量但未初始化时,该变量的默认值是undefined。还有就是函数无明确的返回值时,返回的也是undefined。
    var a; -- undefined

null表示变量的值是空,undefined则表示只声明了变量,但还没有赋值。

object类型

var a = 'xx';
var b = new String('oo');
数组
var a = [11,22,33];
typeof a; -- "object"

var b = new Array([11,22,33,44]);
typeof b; -- "object"
数组常用方法
var a = [11,22,33];
索引取值 -- a[0];
数组长度 -- a.length;
尾部追加 -- a.push(44);
尾部删除 -- a.pop()
    示例:
        var a = [11, 22, 33, 44];
        var b = a.pop();
        结果:
            a -- [11, 22, 33]
            b -- 44
头部添加 -- a.unshift('aa')
    示例:
         var a = [11, 22, 33];
         a.unshift('aa')
         a --  ["aa", 11, 22, 33]
头部删除 -- shift()
    示例:
        var a = ["aa", 11, 22, 33];
        a.shift() -- 'aa'
        a -- [11, 22, 33];

切片 -- slice()
    var b = a.slice(0,3);
    b -- [11, 22]
反转 reverse()
    var a = [11,22,33];
    a.reverse()
    a -- [33,22,11]

数组元素拼接 join
    示例:
        var a = ['aa','bb','cc'];
        var b = a.join('_');
        b -- "aa_bb_cc";

数组合并 concat
    var a = ["aa", "bb", "cc"];
    var b = [11,22];
    var c = a.concat(b);
    c -- ["aa", "bb", "cc", 11, 22];
排序 sort 比较尬
    示例:
        var a = [12,3,25,43];
        对a进行升序排列:
        1 定义函数
            function sortNumber(a,b){
                return a - b
             };
        2 var b = a.sort(sortNumber)
        b -- [3, 12, 25, 43]
    sort 规则:
          如果想按照其他标准进行排序,就需要提供比较函数,也就是自己提供一个函数提供排序规则,该函数要比较两个值,然后返回一个用于说明这两个值的相对顺序的数字。比较函数应该具有两个参数 a 和 b,其返回值如下:
      若 a 小于 b,在排序后的数组中 a 应该出现在 b 之前,则返回一个小于 0 的值。
      若 a 等于 b,则返回 0。
      若 a 大于 b,则返回一个大于 0 的值。

删除 .splice()
    示例:
        var a = ['aa','bb',33,44];
        单纯删除:a.splice(1,1)
        a -- ["aa", 33, 44]

        删除在替换新元素:
        var a = ["aa", 33, 44];
        a.splice(0,2,'hello','world');
        a --  ["hello", "world", 44];
    三个参数介绍:
        参数:1.从哪删(索引), 2.删几个  3.删除位置替换的新元素(可多个元素)
自定义对象 -- python字典
索引取值
    var a = {'name':'alex','age':48};
    键可以不加引号:var a = {name:'alex',age:48};
    a['age']; -- 48
    a.age; -- 48
类型查询

运算符

算数运算符
+ - * / % ++ --  i++,是i自加1,i--是i自减1   i++的这个加1操作优先级低,先执行逻辑,然后再自加1,而++i,这个加1操作优先级高,先自加1,然后再执行代码后面的逻辑

示例:
    var a = 100;
    a++;或者++a; -- 101 a自增1

    a++和++a的区别,示例:
    var a = 102;
    a++ == 102; -- true
    a -- 103;
    ++a == 103; -- false
    a -- 104;
比较运算符
> >= < <= != == === !==

==(弱等于)和===(强等于)两者的区别:
    示例:
        var a = 11;
        var b = '11';
        a == b -- true
        a === b; -- false
逻辑运算符
&& || !  #and,or,非(取反)!null返回true
示例:
    var a = true;
    var b = true;
    var c = false;
    a && b; -- true
    a && c; -- false
    a || c; -- true
    !c; -- true
赋值运算符
= += -= *= /=
示例: n += 1其实就是n = n + 1

流程控制

if判断

简单if-else判断
    var a = 4;
    if (a > 5){
        console.log('a大于5');

    }
    else{
        console.log('小于5');
    };

多条件判断
var a = 10;
if (a > 5){
  console.log("a > 5");
}else if(a < 5) {
  console.log("a < 5");
}else {
  console.log("a = 5");
}

switch 切换

示例:
    var a = 1;
    switch (a++){ //这里day这个参数必须是一个值或者是一个能够得到一个值的算式才行,这个值和后面写的case后面的值逐个比较,满足其中一个就执行case对应的下面的语句,然后break,如果没有加break,还会继续往下判断
        case 1:
            console.log('等于1');
            break;
        case 3:
            console.log('等于3');
            break;
        default:  case都不成立,执行default
            console.log('啥也不是!')    

    }
    

for循环

for (var i=0;i<10;i++) {  //就这么个写法,声明一个变量,变量小于10,变量每次循环自增1,for(;;){console.log(i)};这种写法就是个死循环,会一直循环,直到你的浏览器崩了,就不工作了,回头可以拿别人的电脑试试~~
  console.log(i);
}
循环数组:
var l2 = ['aa','bb','dd','cc']
方式1
for (var i in l2){
   console.log(i,l2[i]);
}
方式2
for (var i=0;i<l2.length;i++){
  console.log(i,l2[i])
}

循环自定义对象:
var d = {aa:'xxx',bb:'ss',name:'小明'};
for (var i in d){
    console.log(i,d[i],d.i)  #注意循环自定义对象的时候,打印键对应的值,只能是对象[键]来取值,不能使用对象.键来取值。
}

while循环

var i = 0;
var a = 10;
while (i < a){
    console.log(i);
    if (i>5){
        continue;
        break;
    }
    i++;
};

三元运算

var c = a>b ? a:b;  

函数

定义函数

普通函数
function f1(){
    console.log('111');
}
f1();  执行函数

带参数的函数
function f1(a,b){
    console.log('111');
}
f1(1,2);

带返回值的函数
function f1(a,b){
    return a+b;
}
f1(1,2); -- 3

返回值不能有多个
function f1(a,b){
    return a,b;
}
f1(1,2); -- 2
function f1(a,b){
    return [a,b];  想要多个返回值,需要换一种数据类型
}
f1(1,2); -- [1, 2]

匿名函数:
    var f1 = function(){
        console.log('111');
    }
    f1();

自执行函数
    (function(a,b){
        console.log(a+b);
    })(1,2);

函数的全局变量和局部变量

局部变量:

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

全局变量:

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

变量生存周期:

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

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

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

作用域

首先在函数内部查找变量,找不到则到外层函数查找,逐步找到最外层。

var city = "BeiJing";
function f() {
  var city = "ShangHai";
  function inner(){
    var city = "ShenZhen";
    console.log(city);
  }
  inner();
}
f();  

var city = "BeiJing";
function Bar() {
  console.log(city);
}
function f() {
  var city = "ShangHai";
  return Bar;
}
var ret = f();
ret();

闭包:
    var city = "BeiJing";
    function f(){
        var city = "ShangHai";
        function inner(){
            console.log(city);
        }
        return inner;
    }
    var ret = f();
    ret();

面向对象

function Person(name){
    this.name = name;
};

var p = new Person('taibai');  

console.log(p.name);

Person.prototype.sum = function(a,b){  //封装方法
    return a+b;
};

p.sum(1,2);
3

date对象

//方法1:不指定参数
var d1 = new Date(); //获取当前时间
console.log(d1.toLocaleString());  //当前2时间日期的字符串表示
//方法2:参数为日期字符串
var d2 = new Date("2004/3/20 11:12");
console.log(d2.toLocaleString())

常用方法
var d = new Date();
使用 d.getDate()
//getDate()                 获取日
//getDay ()                 获取星期 ,数字表示(0-6),周日数字是0
//getMonth ()               获取月(0-11,0表示1月,依次类推)
//getFullYear ()            获取完整年份
//getHours ()               获取小时
//getMinutes ()             获取分钟
//getSeconds ()             获取秒
//getMilliseconds ()        获取毫秒
//getTime ()                返回累计毫秒数(从1970/1/1午夜),时间戳

JSON对象

var a = {'name':'太白','age':89};
序列化:var b = JSON.stringify(a);
反序列化:var c = JSON.parse(b);

RegExp对象

var reg1 = new RegExp("^[a-zA-Z][a-zA-Z0-9_]{5,11}$");
// 简写方式
var reg2 = /^[a-zA-Z][a-zA-Z0-9_]{5,11}$/; 

坑:
    reg2.test(); 什么也不填写,会默认成reg2.test('undefined');
    如果'undefined'满足你的正则要求,就返回true

字符串使用正则是的一些方法
var s2 = "hello world";
s2.match(/o/);  匹配元素
s2.match(/o/g);  加上g是全局匹配
s2.search(/o/);  找符合正则规则的字符串的索引位置
s2.split(/o/);  用符合正则的字符串进行分割

var s3 = 'Alex is A xiaosb';
s3.replace(/a/gi,'DSB');  替换,g全局替换,i不区分大小写

正则加g之后,进行test测试需要注意的问题

var reg3 = /a/g;
var s1 = 'alex is a xiaosb';
reg3.lastIndex -- 0
reg3.test(s1); -- true
reg3.lastIndex -- 1
reg3.test(s1); -- true
reg3.lastIndex -- 9
reg3.test(s1); -- true
reg3.lastIndex -- 13

reg3.test(s1); -- false

置零:
    reg3.lastIndex = 0

Math对象

Math.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)      返回角的正切。

原文地址:https://www.cnblogs.com/zhangchaoyin/p/11537433.html

时间: 2024-10-16 23:55:46

百万年薪python之路 -- JS基础介绍及数据类型的相关文章

百万年薪python之路 -- JS的BOM与DOM对象

BOM对象 location对象 location.href 获取URL location.href="URL" // 跳转到指定页面 location.reload() 重新加载页面,就是刷新一下页面 定时器 1. setTimeOut() 一段时间之后执行某个内容,执行一次 示例 var a = setTimeout(function f1(){confirm("are you ok?");},3000); var a = setTimeout("co

百万年薪python之路 -- MySQL数据库之 常用数据类型

MySQL常用数据类型 一. 常用数据类型概览 # 1. 数字: 整型: tinyint int bigint 小数: float: 在位数比较短的情况下不精确 double: 在位数比较长的情况下不精确 0.000001230123123123 存成: 0.000001230000 decimal: (如果用小数,则推荐使用decimal) 精准 内部原理是以字符串形式去存 # 2. 字符串: char(10): 简单粗暴,浪费空间,存取速度快. root存成root000000 varcha

百万年薪python之路 -- 模块二

1. 序列化模块 什么是序列化呢? 序列化的本质就是将一种数据结构(如字典.列表)等转换成一个特殊的序列(字符串或者bytes)的过程就叫做序列化. 为什么要有序列化模块? 如果你写入文件中的字符串是一个序列化后的特殊的字符串,那么当你从文件中读取出来,是可以转化回原数据结构的. 作用及用途 序列化模块就是将一个常见的数据结构转化成一个特殊的序列,并且这个特殊的序列还可以反解回去.它的主要用途:文件读写数据,网络传输数据. 1.1 json序列化(很重要) 不同语言都遵循json数据转化格式,即

百万年薪python之路 -- 并发编程之 多线程 二

1. 死锁现象与递归锁 进程也有死锁与递归锁,进程的死锁和递归锁与线程的死锁递归锁同理. 所谓死锁: 是指两个或两个以上的进程或线程在执行过程中,因为争夺资源而造成的一种互相等待的现象,在无外力的作用下,它们都将无法推进下去.此时称系统处于死锁状态或系统产生了死锁,这些永远在相互等待的进程称为死锁进程 # 多个线程多个锁可能会产生死锁 from threading import Thread from threading import Lock import time lock_A = Lock

百万年薪python之路 -- MySQL数据库之 完整性约束

MySQL完整性约束 一. 介绍 为了防止不符合规范的数据进入数据库,在用户对数据进行插入.修改.删除等操作时,DBMS自动按照一定的约束条件对数据进行监测,使不符合规范的数据不能进入数据库,以确保数据库中存储的数据正确.有效.相容. 约束条件与数据类型的宽度一样,都是可选参数,主要分为以下几种: 约束条件: primary key (PK) 标识该字段为该表的主键,可以唯一的标识记录 foreign key (FK) 标识该字段为该表的外键 not null 标识该字段不能为空 unique

百万年薪python之路 -- 模块

1.自定义模块 1.1.1 模块是什么? 模块就是文件,存放一堆常用的函数和变量的程序文件(.py)文件 1.1.2 为什么要使用模块? 1.避免写重复代码,从文件级别组织程序,更方便管理 2.可以多次利用,我们不仅仅可以把这些文件当做脚本去执行,还可以把他们当做模块来导入到其他的模块中,实现了功能的重复利用 3.拿来主义,提升开发效率 同样的原理,我们也可以下载别人写好的模块然后导入到自己的项目中使用,这种拿来主义,可以极大地提升我们的开发效率,避免重复造轮子. 1.1.3 模块的分类 Pyt

百万年薪python之路 -- 装饰器

装饰器 1.1 开放封闭原则 开放封闭原则具体定义是这样: 1.对扩展是开放的 我们说,任何一个程序,不可能在设计之初就已经想好了所有的功能并且未来不做任何更新和修改.所以我们必须允许代码扩展.添加新功能. 2.对修改是封闭的 因为我们写的一个函数,很有可能已经交付给其他人使用了,如果这个时候我们对函数内部进行修改,或者修改了函数的调用方式,很有可能影响其他已经在使用该函数的用户. 定义:在不改变原被装饰的函数的源代码以及调用方式下,为其添加额外的功能. 实现真正的开放封闭原则:装饰器. 运用闭

百万年薪python之路 -- 并发编程之 多进程二

1. 僵尸进程和孤儿进程 基于unix的环境(linux,macOS) 主进程需要等待子进程结束之后,主进程才结束 主进程时刻检测子进程的运行状态,当子进程结束之后,一段时间之内,将子进程进行回收. 为什么主进程不在子进程结束后马上对其回收呢? 主进程与子进程是异步关系,主进程无法马上捕获子进程什么时候结束 如果子进程结束之后马上在内存中释放资源,主进程就没有办法检测子进程的状态. Unix针对于上面的问题提供了一个机制 所有的子进程结束之后,立马会释放掉文件的操作链接和内存的大部分数据,但是会

百万年薪python之路 -- MySQL数据库之 永久修改字符串编码 与 忘了密码和修改密码

永久修改字符集编码的方法: 在mysql安装目录下创建一个my.ini(Windows下)文件,写入下面的配置,然后重启服务端. [client] #设置mysql客户端默认字符集 default-character-set=utf8 [mysql] # 设置mysql客户端默认字符集 default-character-set=utf8 user = 'root' password = '123' [mysqld] #设置3306端口 port = 3306 # 设置mysql的安装目录 ba