目录
编码 :escape(对字符串)、encodeURI和encodeURIComponent
解码 unescape\ decodeURI、decodeURIComponent
1、返回值与运算符
- js 里面 true && a ,总是返回a,若false && a,返回false
- true || a,返回 true ,false || a 返回 a
- '' ?? a 返回 ‘’,null ?? a 返回a
- return a,b 返回最后一个b
2、三元运算符
可以这样一直套下去,从上往下走
hour < 8 ? '早上好' : hour <= 11 ? '上午好' : hour <= 13 ? '中午好' : hour < 18 ? '下午好' : '晚上好'
3、url编码与解码
编码 :escape(对字符串)、encodeURI和encodeURIComponent
1、如果只是编码字符串,不和URL有半毛钱关系,那么用escape,而且这个方法一般不会用到。编码之后的效果是%XX或者%uXXXX这种形式。其中 ASCII字母、数字、@*/+ ,这几个字符不会被编码,其余的都会。最关键的是,当你需要对URL编码时,请忘记这个方法,这个方法是针对字符串使用的,不适用于URL。
2、如果你需要编码整个URL,然后需要使用这个URL,那么用encodeURI。
3、当你需要编码URL中的参数的时候,那么encodeURIComponent是最好方法。
encodeURI和encodeURIComponent都是编码URL,唯一区别就是编码的字符范围,其中
编码格式 | encodeURI | encodeURIComponent |
编码 | 不会对下列字符编码 ASCII字母、数字、~!@#$&*()=:/,;?+' | 不会对下列字符编码 ASCII字母、数字、~!*() |
应用场景 | 编码整个URL | 编码URL中的参数 |
对整个url编码后 | 会将http://XXX中的//也编码,会导致URL不可用 | |
url参数有中文 | 编码整个URL,两次编码,否则有可能不会生效 | 只对参数编码用 |
(其实java中的URLEncoder.encode(str,char)也类似于这个方法,会导致URL不可用)
中文参数
URL中文参数两次编码得到正确结果(一次编码不能得到正确结果)
var url =
encodeURI(encodeURI("https://fanyi.baidu.com/#zh/en/钉钉"));
console.log(url);
window.open(url);
总结:
1、 表单get方法提交一次编码就可以
2、如果只对参数编码用encodeURIComponent编码就可以,当然用 encodeURI也可以,如果不生效可以用两次编码。
3、如果是对整个URL进行编码最好用encodeURI,而且是两次编码 ,否则有可能不会生效。
4、判断是否生效只需要看带到后台的参数是否是编码后的格式,或者url的地址是否是编码之后的。
解码 unescape\ decodeURI、decodeURIComponent
对应上面编码即可
4、在浏览器中使用jquery
var jquery = document.createElement('script');
jquery.src = 'https://code.jquery.com/jquery-3.3.1.min.js';
document.getElementsByTagName('head')[0].appendChild(jquery);
5、类型判断等
1、类型判断
instanceof
instanceof
运算符用于检测构造函数的 prototype
属性是否出现在某个实例对象的原型链上。
//语法
object instanceof constructor
//string
var str= "string";
var newStr1= new String();
var newStr2 = new String("string");
str instanceof String; // 返回 false, not a String
str instanceof Object; // 返回 false, not an Object
newStr1 instanceof String; // 返回 true
newStr1 instanceof Date; // 返回 false
newStr1 instanceof Object; // 返回 true
newStr2 instanceof String; // 返回 true
newStr2 instanceof Object; // 返回 true
//obj
var obj = {};
var objnull = Object.create(null);
obj instanceof Object; // 返回 true, 尽管原型没有定义
({}) instanceof Object; // 返回 true, 同上
objnull instanceof Object; // 返回 false, 一种创建非 Object 实例的对象的方法
//data
var date = new Date();
obj instanceof Date; // 返回 true
obj instanceof Object; // 返回 true
obj instanceof String; // 返回 false
1、判断null undefined
undefined
typeof value !== 'undefined' | value !== undefined |
_a === void 0 | |
let _a = (event.detail || {}).value
let value = _a === void 0 ? '' : _a
null
str === null | value !== null |
2、为空判断
/** 数据模块 是否为空 true//没数据*/
export const isEmpty = str => {
if (str === null || str === 'null') return true;
if (str === undefined || str === 'undefined') return true;
if (str.length == 0) return true;
if (JSON.stringify(str) === "{}") return true;
let regu = "^[ ]+$";
let re = new RegExp(regu);
return re.test(str);
}
export const isNotEmpty = str => {
return !isEmpty(str)
}
// 判断 false --全有
// 判断 true --全空,或者有一个为空
export const isOneEmpty = function (...args) {
const len = args.length
for (let i = 0; i < len; i++) {
if (isEmpty(args[i])) return true
}
return false
}
// 判断 false --有1个或者全部不为空
// 判断 true --全空
export const isAllEmpty = function (...args) {
const len = args.length
for (let i = 0; i < len; i++) {
if (!isEmpty(args[i])) return false
}
return true
}
3、 比较两个对象是否相等、判断类型
export const compareObj = { // mark: 对象相关
// 比较两个对象是否相等
compare: function (oldData, newData) {
// 类型为基本类型时,如果相同,则返回true
if (oldData === newData) return true
if (compareObj.isObject(oldData) && compareObj.isObject(newData) && Object.keys(oldData).length === Object.keys(newData).length) {
// 类型为对象并且元素个数相同
// 遍历所有对象中所有属性,判断元素是否相同
for (const key in oldData) {
if (oldData.hasOwnProperty(key)) {
if (!compareObj.compare(oldData[key], newData[key])) {
// 对象中具有不相同属性 返回false
return false
}
}
}
} else if (compareObj.isArray(oldData) && compareObj.isArray(oldData) && oldData.length === newData.length) {
// 类型为数组并且数组长度相同
for (let i = 0, length = oldData.length; i < length; i++) {
if (!compareObj.compare(oldData[i], newData[i])) {
// 如果数组元素中具有不相同元素,返回false
return false
}
}
} else {
// 其它类型,均返回false
return false
}
// 走到这里,说明数组或者对象中所有元素都相同,返回true
return true
},
// 判断此类型是否是Array类型
isObject: function (obj) {
return Object.prototype.toString.call(obj) === '[object Object]'
},
// 判断此对象是否是Object类型
isArray: function (arr) {
// Array.isArray(arr)
// 'Array' === attrs.constructor
return Object.prototype.toString.call(arr) === '[object Array]'
},
// 被定义
isDef : function (v){
return v !== undefined && v !== null
},
isPromise: function (promise) {
return isDef(promise) && typeof promise.then === 'function' &&
typeof promise.catch === 'function'
},
isPromise2: function (val) {
return isPlainObject(val) && isFunction(val.then) && isFunction(val.catch);
}
isFunction: function (val) {
return typeof val === 'function';
},
isPlainObject: function (val) {
return val !== null && typeof val === 'object' && !Array.isArray(val);
},
isObj: function (x) {
var type = typeof x;
return x !== null && (type === 'object' || type === 'function');
},
isNumber: function (value) {
return /^\d+(\.\d+)?$/.test(value);
},
isBoolean: function (value) {
return typeof value === 'boolean';
},
}
4、文件类型
var IMAGE_REGEXP = /\.(jpeg|jpg|gif|png|svg|webp|jfif|bmp|dpg)/i;
var VIDEO_REGEXP = /\.(mp4|mpg|mpeg|dat|asf|avi|rm|rmvb|mov|wmv|flv|mkv)/i;
function isImageUrl(url) {
return IMAGE_REGEXP.test(url);
}
function isVideoUrl(url) {
return VIDEO_REGEXP.test(url);
}
6、对象
1、获取对象指定的属性组成新的新对象
下面两个方法都可用,第一个只能传数组,第二个方法可以传数组也可以传对象
/**
* 获取对象指定的属性组成新的新对象
* certainFunction(obj, ['a', 'b']);
* @param {*} obj 对象
* @param {*} keys arrary
*/
// mark: 组成新的新对象
export function certainFunction(obj, keys) {
return keys.reduce((result, key) => {
let arr = []
if (key) {
arr = key.split('.')
}
key = arr[0]
if (obj.hasOwnProperty(key)) {
if (arr.length > 1) {
if (obj[key].hasOwnProperty(arr[1])) {
result[arr[1]] = obj[key][arr[1]]
}
} else {
result[key] = obj[key];
}
}
return result;
}, {});
}
/**
* @param {*} sour 原对象
* @param {*} tag 目标 (可以是个对象{a:'',b:''},或者是个数组['a','b'])
*/
export function getNewObj(sour, tag) {
if (method.compareObj.isArray(tag)) {
return certainFunction(sour, tag)
}else if(method.compareObj.isObject(tag)){
let newObj = Object.assign({}, tag)
for (let i in newObj) {
if (typeof sour[i] !== 'undefined') {
newObj[i] = sour[i]
}
}
return newObj
}else{
showModal({msg: '目标tag的类型必须是obj或者arr,当前的类型是'+tag.constructor})
}