526互联

JavaScript

发布时间 2024-01-02 11:53:25作者: Way*yy

溢出属性

p {
            height: 100px;
            width: 50px;
            border: 3px solid red;
            /*overflow: visible;  !*默认就是可见 溢出还是展示*!*/
            /*overflow: hidden;  !*溢出部分直接隐藏*!*/
            /*overflow: scroll;  !*设置成上下滚动条的形式*!*/
            /*overflow: auto;*/
        }
值				描述
visible			默认值。内容不会被修剪，会呈现在元素框之外。
hidden			内容会被修剪，并且其余内容是不可见的。
scroll			内容会被修剪，但是浏览器会显示滚动条以便查看其余的内容。
auto			如果内容被修剪，则浏览器会显示滚动条以便查看其余的内容。
inherit			规定应该从父元素继承 overflow 属性的值。

overflow		（水平和垂直均设置）
overflow-x		（设置水平方向）
overflow-y		（设置垂直方向）

定位

  • 静态

    所有的标签默认都是静态的static，无法改变位置

  • 相对定位(了解)

    相对于标签原来的位置做移动relative

  • 绝对定位(常用)

    相对于已经定位过的父标签做移动(如果没有父标签那么就以body为参照)

    eg:小米网站购物车

    当你不知道页面其他标签的位置和参数，只给了你一个父标签的参数，让你基于该标签左定位

  • 固定定位(常用)

    相对于浏览器窗口固定在某个位置

    eg:右侧小广告

1、static-------->默认是静止的，所有标签不可移动
2、relative------->相对定位：就是相对标签自己原来的位置定位
	<style>
		#d1 {
            height: 100px;
            width: 100px;
            background-color: red;
            left: 50px;  /*从左往右   如果是负数 方向则相反*/
            top: 50px;  /*从上往下    如果是负数 方向则相反*/
            /*position: static;  !*默认是static无法修改位置*!*/
            position: relative;
            /*相对定位
            标签由static变为relative它的性质就从原来没有定位的标签变成了已经定位过的标签
            虽然你哪怕没有动 但是你的性质也已经改变了
            */
        	}
	</style>
	<body>
        <div id="d1"></div>
        <div id="d2"></div>
        <div id="d3"></div>
    </body>

3、absolute-------->绝对定位：相对于它的父标签进行定位，如果没有父标签，就相对于body标签
/*如果相对于父标签移动，前提是父标签必须是可移动的，言外之意就是父标签先设置：position: relative;*/
	

4、fixed-------->固定定位：就是相对于浏览器窗口定位

JavaScript简介

一个完整的 JavaScript 实现是由以下 3 个不同部分组成的：

● 核心（ECMAScript） ------------>基础语法---------->必须要会的
● 文档对象模型（DOM） Document object model (整合js，css，html)----------->重要
● 浏览器对象模型（BOM） Broswer object model（整合js和浏览器）------------>不重要

简单地说，ECMAScript 描述了JavaScript语言本身的相关内容。
JavaScript 是脚本语言
JavaScript 是一种轻量级的编程语言。
JavaScript 是可插入 HTML 页面的编程代码。
JavaScript 插入 HTML 页面后，可由所有的现代浏览器执行。

# js的注释
    """
    // 单行注释

    /*
    多行注释1
    多行注释2
    多行注释3
    */
    """

# 两种引入方式
	1.script标签内部直接书写js代码
	2.script标签src属性引入外部js代码

# js语法结构
	js是以分号作为语句的结束
	但是如果你不写分号，问题也不大 也能够正常执行 但是它就相当于没有结束符

变量

"""
	在JavaScript中定义变量的时候需要用关键字声明
		1、关键字var：var name = 'kevin'
		2、es6推出的新语法：let name = 'kevin'
			如果你的编辑器支持的版本是5.1那么无法使用let
			如果是6.0则向下兼容 var let
"""
# var与let的区别
n = 10
for n in range(5):
  print(n)
print(n)  
# var 5		let 10

"""
var在for循环里面定义也会影响到全局
let在局部定义只会在局部生效
"""

常量

# 在Python中没有真正意义上的常量，默认全部大写的就是常量
# JavaScript中有真正意义上的常量
定义常量：
	const pi = 3.14

数据类型

// 查看数据类型 :typeof
    var a = 1;
    var b = 1.11;
    console.log(typeof a); // number
    console.log(typeof b);

1、数值类型（Number）
	// 整数和小数都是数值类型

2、类型转换
	var a = 1;
    console.log(typeof a); // Number
    var a = '123'
    console.log(typeof a) //string
    // 特殊的 NaN:数值类型 表示的意思是“不是一个数字” NOT A NUMBER

3、字符串（string）
    let s = 'hello';
    let ss = 'HelloKitty'
    console.log(s + ss); // helloHelloKitty
string的常用方法：
let ss = 'HelloKitty' 
	1、.length	返回长度
        1.1、console.log(ss.length) //10

    2、.trim()	移除空白
    3、.trimLeft()	移除左边的空白
    4、.trimRight()	移除右边的空白
        2.1、console.log(ss.trim())
        3.1、console.log(ss.trimLeft())
        4.1、console.log(ss.trimRight())
    5、 .charAt(n)	返回第n个字符
    	5.1、console.log(ss.charAt(5)) //e
    6、 .indexOf(substring, start)	子序列位置
    	6.1、console.log(ss.indexOf('K')) //9
    7、 .substring(from, to)		根据索引获取子序列
    	7.1、console.log(ss.substring(0,5)) //Hello
    8、 .slice(start, end)	切片
    	8.1、console.log(ss.substring(0,5)) //Hello
    9、 .toLowerCase()	小写
    	9.1、console.log(ss.toLowerCase()) //hellokitty
    10、.toUpperCase()	大写
    	10.1、console.log(ss.toUpperCase()) //HELLOKITTY
    11、.split(delimiter, limit)		分割
    	11.1、console.log(ss.split(',')) //['He', 'llo', 'Ki', 'tty']

####################################################################
4、ES6中引入了模版字符串
    let name = 'kevin';
    let age = '18';
    let info = `my name is ${name} and my age is ${age}`;
    console.log(info) //my name is kevin and my age is 18

5、布尔值（Boolean）
true、false
	// JS中哪些为假？
	"""(空字符串)、0、null、underfined、NaN都为假

6、null和underfined
	null表示为空，一般在需要指定的或者清空一个变量时才会使用，如name = null
	underfined表示当声明一个变量但未初始化时，该变量的默认值就是underfined，还有函数没有明确返回值时返回的也是underfined

数组的数据类型

数组-------->Python的列表
常用方法：
	方法					说明
.length					数组的大小
.push(ele)				尾部追加元素
.pop()					获取尾部的元素
.unshift(ele)			头部插入元素
.shift()				头部移除元素
.slice(start, end)		 切片
.reverse()				反转
.join(seq)				将数组元素连接成字符串
.concat(val, ...)		 连接数组
.sort()					排序
.forEach()				将数组的每个元素传递给回调函数
.splice()				删除元素，并向数组添加新元素。
.map()					返回一个数组元素调用函数处理后的值的新数组

运算符

// 算术运算符
+ - * / % ++ --
	let x = 10;
    let y = x++;
    let z = ++x
    console.log(y,z) //10、12
    //++表示自增1 类似于 +=1
    //加号在前先加后赋值 加号在后先赋值后加

//比较运算符
> >= < <= != == === !==
    1 == '1'；//true  弱等于，只会比较两个值是否相等
    1 === '1'；//false 强等于，不止会比较值是否相等还会比较类型是否相等，两个都相等为true，否则为false
    
//逻辑运算符
&&（and） ||(or)  !(not)

// 赋值运算符
= += -= *= /=

流程控制

// 单分支的if else 语句
	let x = 10;
    let y = 20;
    if (x>y){
        console.log(x)
    }else {
        console.log(y)
    }
//多分支的if else语句
	let x = 10;
    let y = 10;
    if (x>y){
        console.log(x)
    }else if (x < y){
        console.log(y)
    }else{
        console.log("DSB")
    }
// 在js中代码是没有缩进的 只不过我们处于python书写习惯人为的加上了而已
    ()条件
    {}代码块
    
// Switch语法
    let num = 3;
    switch (num){
        case 0:
            console.log("喝酒");
            break;
        case 1:
            console.log("唱歌")
            break;
        case 2:
            console.log("洗脚")
            break;
        case 3:
            console.log("按摩");
            break;
        default:
            console.log("没钱不要来")
    }

//for循环
	for (let i = 0; i < 10;i++){
        console.log(i)
    }
//题目1  循环打印出数组里面的每一个元素
	var l1 = [111,222,333,444,555,666]
    for (let i = 0;i < l1.length;i++){
        console.log(l1[i])
        
//while循环
    let i = 0;
    while (i < 100){
        console.log(i)
        i++
    }
        
//三元运算符:条件成立取问好后面的1 不成立取冒号后面的3
	let x = 2 > 5?'yes':'no'
    console.log(x)
    //嵌套关系的
        let x = 2 > 3 ? '1' :(8 > 5 ? '2' : '3')
    	console.log(x) //2

函数

//在Python中定义函数关键字是def
//在JavaScript中定义函数的关键字是function
语法格式：
	function 函数名(形参1,形参2,形参3...){函数体代码}

无参函数：
	function index() {
        console.log("hello word")
    }

    index() //hello word
有形参无实参的情况
    function index(a,b) {
            console.log(a,b)
        }

    index() //undefined undefined
有参函数：
	function index(a,b) {
        console.log(a,b)
    }

    index(1,2) //1 2

    function index(a,b,c,d,e) {
        console.log(a,b,c,d,e)
    }

    index(1,2) //1 2 undefined undefined undefined

	function index(a,b) {
        console.log(a,b)
    }

    index(1,2,3,4,5,6,7) //1 2

	//arguments会接收所有的参数
	function index(a,b) {
        console.log(a,b)
        console.log(arguments)
    }

    index(1,2,3,4,5,6,7) //[1, 2, 3, 4, 5, 6, 7]
    
//函数的返回值
	function index(a,b) {
        return a+b
    }

    res = index(1,2)
    console.log(res) //3
	// 返回多个只能拿到最后一个

    function index(){
      return [666,777,888,999]
    }
    //js不支持解压赋值

//匿名函数
	let res = function (){
        console.log("nihao")
    }
    res()

//箭头函数(要了解一下)  主要用来处理简单的业务逻辑 类似于python中的匿名函数
var func1 = v => v;  """箭头左边的是形参 右边的是返回值"""
等价于
var func1 = function(v){
  return v
}

var func2 = (arg1,arg2) => arg1+arg2
等价于
var func1 = function(arg1,arg2){
  return arg1+arg2
}

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

//跟python查找变量的顺序一致
var city = "BeiJing";
function f() {
  var city = "ShangHai";
  function inner(){
    var city = "ShenZhen";
    console.log(city);
  }
  inner();
}

f();  //输出结果是？ shanghai


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();

自定义对象

//你可以看成是我们python中的字典 但是js中的自定义对象要比python里面的字典操作起来更加的方便

//创建自定义字典
第一种创建自定义字典方式
    let d = {name:"kevin",age:18}
    console.log(d,typeof d) //{name: 'kevin', age: 18} 'object'
	//取值方式
	console.log(d['name']) //kevin
    console.log(d.name) //kevin
	//支持for循环
	for (let i in d){
        console.log(i,d[i])
    }

"""第二种创建自定义对象的方式  需要使用关键字 new"""
var d2 = new Object()  //相当于{}

d2.name = 'jason'
{name: "jason"}

d2['age'] = 18
{name: "jason", age: 18}

date对象

let d3 = new Date()
Fri May 15 2020 14:41:06 GMT+0800 (中国标准时间)
   
d3.toLocaleString()
"2020/5/15 下午2:41:06"

# 也支持自己手动输入时间
let d4 = new Date('2200/11/11 11:11:11')
d4.toLocaleString()

let d5 = new Date(1111,11,11,11,11,11)
d5.toLocaleString()  # 月份从0开始0-11月
"1111/12/11 上午11:11:11"

# 时间对象具体方法
let d6 = new Date();
d6.getDate()  获取日
d6.getDay()		获取星期
d6.getMonth()		获取月份(0-11)
d6.getFullYear()		获取完整的年份
d6.getHours()			获取小时
d6.getMinutes()		获取分钟
d6.getSeconds()		获取秒
d6.getMilliseconds()  获取毫秒
d6.getTime()					时间戳

json对象

"""
在python中序列化反序列化
	dumps 		序列化
	loads		反序列化

在js中也有序列化反序列化
	JSON.stringify()------===------dumps
	JSON.parse()------===------loads			
"""
let d7 = {'name':'jason','age':18}
let res = JSON.stringify(d7)
"{"name":"jason","age":18}"

JSON.parse(res)
{name: "jason", age: 18}