求任意数组的最大值
function maxNum(arr){
var max=arr[0];
for (var i = 0; i < arr.length; i++) {
if(max<arr[i]){
max=arr[i];
};
};
console.log(max);
};
求任意数组的最小值
function minNum(arr){
var min=arr[0];
for (var i = 0; i < arr.length; i++) {
if(min>arr[i]){
min=arr[i];
};
};
console.log(min);
}
//求任意范围数字和
function addArr(min,max){
var sun=0;
for (var i = min; i <= max; i++) {
sun+=i;
};
console.log(sun);
};
求任意数字的总和
function addNum(a,b,c,...values){
//rest参数 做为形参最后一个参数
console.log(values)
}
// type 检测参数数据类型 根据 < > 求最大或最小值
function best(a,type){
if(type=="<"){
minNum(arr1);
}
if(type==">"){
maxNum(arr1);
}
}
在数组后面添加元素
function push(arr,...values){
for (var i = 0; i < values.length; i++) {
arr[arr.length]=values[i]
};
return arr;
}
递归函数
function down(num){
if(num<=0){
// console.log(num)
return 0;
}else {
down(--num);
console.log(num)
}
}
阶乘函数
function jiecheng(num){
var sun=1
for (var i = num; i >=1; i--) {
sun*=i
};
console.log(sun)
}
function jie(num){
if(num==1){
return 1;
}else{
return num*jie(--num)
}
}
从小到大排序
function xiao(arr){
for (var i = 0; i < arr.length; i++) {
for(var j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
var tt=arr[i];
arr[i]=arr[j];
arr[j]=tt;
}
}
}
return arr;
}
从大到小排序
function da(arr){
for (var i = 0; i < arr.length; i++) {
for(var j=i+1;j<arr.length;j++){
if(arr[i]<arr[j]){
var tt=arr[i];
arr[i]=arr[j];
arr[j]=tt;
}
}
}
return arr;
}
根据type类型判断排序方式
function pai(arr,type='<'){
if(arguments.length<1 || arguments.length>2){
return "请输入参数";
}
if(!(arr instanceof Array&&arr.length>1)){
return '请输入正确的数组'
}
if(type!='<' && type!='>'){
return "请输入正确类型";
}
if(type=='<'){
return xiao(arr)
}else if(type=='>'){
return da(arr)
}
}
判断一个字符串中是否包含另一个字符串
function isInClude(str,str2){
if(str.indexOf(str2)==-1){
return false;
}else{
return true;
}
}
将制定的字符串替换成'*'号
function tihuan(str,str1){
// str是原字符串 str1是要替换掉的内容
let xing='';
for (var i = 0; i < str1.length; i++) {
// 通过循环判断要替换内容的长度，来决定*号的数量
xing+="*"
};
//可以用let xing='*'.repeat(str1.length)替换
let newstr=str;
while(newstr.match(str1)!=null){
// 可用(newstr.indexOf(str1)!=-1)替换
// 通过循环不停的替换，然后赋值给新的字符串
newstr=newstr.replace(str1,xing)
}
return newstr;
}
不区分大小写比较两个字符串大小
function bijiao(str,str1){
if(str.toLowerCase()>str1.toLowerCase()){
return 'str>str1';
}else{
return 'str<str1';
}
}
打印出一段字符串中某一节字符串的位置 方法1
function dump(str,str1){
let arr=[]
let xing="*".repeat(str1.length)
let newstr=str;
while(newstr.match(str1)!=null){
arr.push(newstr.indexOf(str1))
// 通过空数组保存下标 然后在循环外部return，避免直接终止循环，可以在最后获取到下标值，从而进行操作
newstr=newstr.replace(str1,xing);
}
return arr;
}
打印出一段字符串中某一节字符串的位置 方法2
function dumpF(str,str1){
let arr=[];
for (var i = 0; i < str.length; i++) {
if(str.substr(i,str1.length)===str1){
arr.push(i);
}
}
return arr;
}
查找数组内随机元素
function yuansu(a,b){
if(a instanceof Array && arguments.length==2){
// 参数a是一个数组对象，并且参数为2
var arr=[];
for (var i = 0; i <b; i++) {
var num=Math.floor(Math.random()*b);
arr.push(a[num]);
};
return arr;
}
}
判断数组内是否存在 > 0
function a1 (arr) {
if(!(arr instanceof Array)){
return;
}
for (var i = 0; i < arr.length; i++) {
if(arr[i]>0){
return true;
}
};
return false;
}
判断数组内是否所有元素都 > 0
function a2(arr) {
for (var i = 0; i < arr.length; i++) {
if(arr[i]<=0){
return false;
}
};
return true;
}
筛选数组内 > 0 的元素
function filter(arr){
let newarr=[];
for (var i = 0; i < arr.length; i++) {
if(arr[i]>0){
newarr.push(arr[i]);
}
}
return newarr;
}
判断数组内是否存在某一个元素
function arrP(arr,ele){
for (var i = 0; i < arr.length; i++) {
if(arr[i]==ele){
return true;
}
};
}
删除数组重复的元素
function quchong1(arr){
let newarr=[];
for (var i = 0; i < arr.length; i++) {
if(newarr.indexOf(arr[i])==-1){
// 当newarr里查询不到arr[i]的时候，插入
newarr.push(arr[i]);
}
}
return newarr;
}
function quchong2(arr){
let newarr=[];
for (var i = 0; i < arr.length; i++) {
var flag=arrP(newarr,arr[i]);
// 调用另外一个函数，判断newarr里是否包含arr[i]
if(!flag){
newarr.push(arr[i])
}
}
return newarr;
}
function quchong3(arr){
// 如果当前数组的第i项在当前数组中第一次出现的位置不是i，那么表示第i项是重复的，忽略掉。否则存入结果数组
var newArr = [];
for(var i=0, len=arr.length; i<len; i++){
if(arr.indexOf(arr[i]) == i){
newArr.push(arr[i]);
}
}
return newArr;
}
数组内随机获取任意个元素
function a5(arr){
let newarr=[];
let n=Math.floor(Math.random()*arr.length);
// 让获取的元素个数随机
for (var i = 0; i < n; i++) {
let num=Math.floor(Math.random()*arr.length);
// 让获取元素的内容随机
newarr.push(arr[num]);
// 插入新数组
}
return newarr;
}
数组里随机获取任意个不重复元素
function a6(arr){
let newarr=[];
let n=Math.floor(Math.random()*arr.length);
// 让获取的元素个数随机
for (var i = 0; i < n; i++) {
let num=Math.floor(Math.random()*arr.length);
// 让获取元素的内容随机
while(newarr.includes(arr[num])){
// 再循环的时候更新显示的数量，arr的下标
num=Math.floor(Math.random()*arr.length);
n=Math.floor(Math.random()*num);
}
newarr.push(arr[num]);
}
return newarr;
}
让获取元素
function $(selector,ranger=document){
let type=typeof selector;
// 检查参数的数值类型，是字符串还是函数
if(type=="string"){
// 获取
let select=selector.trim();
// 去除字符串开始的空格，防止传参失误
let first=select.charAt(0);
// console.log(select.substr(1))
if(first=='.'){
return ranger.getElementsByClassName(select.substr(1),ranger)
// 返回类名 此时select已经是字符串，所以括号内不用输入引号。
}
if(first=='#'){
return document.getElementById(select.substr(1))
// 返回id名
}
if(/^[a-zA-Z][a-zA-Z1-6]{0,8}$/.test(select)){
return ranger.getElementsByTagName(select)
}
if(/^<[a-zA-Z][a-zA-Z1-6]{0,8}>$/.test(select)){
// 创建一个
return document.createElement(select.slice(1,-1))
}
}
if(typeof(selector)=="function"){
//添加
addEvent(window,'load',selector)
// window.addEventListener('load',selector)
// window.onload=function () {
// selector()
// }
}
}
封装样式(实现兼容)
function getStyle(obj,attr){
if(window.getComputedStyle){//把方法当做一个属性
// alert('1');
return getComputedStyle(obj,null)[attr];
}else{
// alert('2');
return obj.currentStyle[attr];
}
}
// /ml(obj[,content])方法
//获取或设置某一个元素的内容
//obj指定的对象
//[content]设置的内容（可有[设置]可无[获取]）
function html(obj,content){
if(content){
//设置
obj.innerHTML=content;
}else{
//获取
return obj.innerHTML;
}
}
动画函数
// animate(box,{width:400,height:400,left:300},function(){
// box.style.background='green'
// })
// animate(box,{width:400,height:400,left:300},function(){
// animate(box,{left:100})
// })
function animate(obj,attr,callback){
// 对象，对象的属性和值 json格式 ，回调函数
let t=setInterval(move,200);
function move(){
for(let i in attr){
let currentV=parseInt(getComputedStyle(obj,null)[i])+10;
// 获取当前obj的长宽属性
if(currentV>=attr[i]){
// 如果实际尺寸达到要求，
currentV=attr[i];
// 让当前的值等于要求尺寸
clearInterval(t);
// 就清除时间函数
if(callback){
// 回调函数
callback.call()
}
}
obj.style[i]=currentV+'px';
}
}
}
获取父元素下所有的子元素集合 标签
function getChilds(obj){
let arr=[]
obj.childNodes.forEach(function(value,index){
if(value.nodeType==1){
arr.push(value)
}
})
return arr;
获取父元素下第一个标签元素
function first (obj) {
return getChilds(obj)[0];
}
获取父元素下最后一个标签元素
function last (obj) {
let childs=getChilds(obj);
return childs[childs.length-1]
}
把一个子元素插入到一个父元素中，扩充到body上,使用的时候 子元素的appendTo(父元素),会直接插入到你想要的父元素
Node.prototype.appendTo=function (parent) {
parent.appendChild(this)
};
addEvent(obj,'click',fn)
function addEvent(obj,type,fn) {
obj.addEventListener(type,fn,false);
}
判断兼容，滚轮事件，向上滑动选择一个事件，向下另外一个
function mousewheel(obj,unfn,downfn) {
obj.addEventListener('mousewheel',fn,false)
function fn(e) {
let dir=e.wheelDelta;
if(dir==120 || dir==180 || dir==150){
unfn.call(obj);
}
if(dir==-120 || dir==-180 || dir==-150){
downfn.call(obj);
}
}
}
// 调用
// mousewheel(box,function () {
// this.style.background='yellow'
// },function () {
// this.style.background='green'
// })
金字塔
function jin(){
let a =30
for(let b = 1; b <= a; b++) {
for(let c = (a-b) *2 ; c >= 0; c--) {
document.write(" ");
}
for(var d = 1; d <= b - 1; d++) {
document.write("A" + "  ");
}
document.write("<br/>");
}
}
var aa=null
functiong(){
}
$(body).on('click','.addphoto',function(){
aa=null;
$("#eadimg").click()
})
$(body).on('click','[data-key="content"]',function(){
aa=this;
$("#eadimg").click()
})
