js 面试题

1，下面代码的输出结果

var num1 =  55;
var num2 =  66;  
function f1(num,num1){
    num  = 100; //函数私有
    num1 = 100; //函数私有
    num2 = 100; //全局变量
    console.log(num); //100
    console.log(num1); //100
    console.log(num2); //100
} 
f1(num1,num2)
console.log(num1); //55
console.log(num2); //全局的被修改为100，所以这里打印出来的也是100
console.log(num);  //全局作用域里没有这个，找不到报错

2，js实现斐波那契数列

斐波那契数列数列：0 1 1 2 3 5 8 13...，用数学公式表示为：fn(n) = fn(n-1) + fn(n-2), n>1; fn(0) = 0; fn(1) = 1; 简单的来说就是后一项是前两项只和。

1,2,4,8 //等比

0,2,4,6 //等比

/* 递归 */
 function fb1(n) {
     if (n < 1)
         return -1;
     if (n == 1 || n == 2)
         return 1;
     return fb1(n - 1) + fb1(n - 2);

 }
 console.log(fb1(12));//144
 //不建议用递归，性能太差，超过40 就超级慢了50 需要四分多钟
 
 方法2：循环实现
 function fabonacci(n) {
      var last = 0;
      var laster = 1;
      var current = last;
      for (var i = 1; i <= n; i++) {
        last = laster;
        laster = current;
        current = last + laster;
      }
      return current;
    }
    var start = new Date();
    var result = fabonacci(50);
    var end = new Date();
    console.log('方法二', result, end.getTime() - start.getTime());

3，下面代码的输出结果（宏观任务，微观任务）  

我们把宿主发起的任务称为宏观任务，把 JavaScript引擎发起的任务称为微观任务。许多的微观任务的队列组成了宏观任务。
宏观任务(marcotask):
    setTimeout,setInterval
    requestAnimationFrame
    解析HTML
    执行主线程js代码
    修改url
    页面加载
    用户交互

微观任务(mircotask):
    promise
    mutation.oberver
    process.nextTick

<script type="text/javascript">
console.log('start')

setTimeout(function(){
    console.log('setTimeout')
},0)

var p = new Promise(function(resolve, reject){
    console.log('new1')
    resolve('产生回调')
    
}).then(function(){
    console.log('promise1111')
}).then(function(){
    console.log('promise222')
});

console.log('end')
</script>
输出结果：start
         new1
         end
         promise1111
        promise222
        setTimeout
 JS 引擎首先会把Promise对象  微观任务存入执行栈，把 setTimeout（宏观任务）存入 “任务队列”
不会按照预期那样立即从 “任务队列” 中读取 setTimeout，因为 then方法是微观任务Promise对象的回调函数，先于 setTimeout 执行

4, 什么是宏任务，什么是微任务  

宏任务和微任务都是异步任务在同步任务队列之后

 而宏任务是:计时器等。

微任务:原生Promise

执行顺序
微观任务先于宏观任务

5, 闭包是什么，闭包的作用是什么

函数内访问外面的变量

稍微复杂点，就是一个函数做为值在另外一个函数内返回，并且使用了，外层函数的变量）

作用：防止全局污染，保存外部活动变量

闭包案例：
//非闭包，输出值，无变化
function add() {
  var x = 1;
  console.log(++x);
}
add(); //执行输出2,
add(); //执行还是输出2,
//怎样才能使每次执行有加 1 效果呢?使用闭包
function add() {
  var x = 1;
  return function() {
    console.log(++x);
  };
}
var num = add();
num(); //输出2,
num(); //输出3,
num(); //输出4, 

6，代码打印结果

 var text=(function(i){
    return function(){
        alert(i*2)
    }   
}(3))
text(5)

//输出 6，自执行函数，使用的是自己的参数，
//自执行函数相当于一个瓶口朝下的杯子，当定义它的时候，它会倾斜，把杯口露出来，吸收外面的新鲜空气；当它执行完毕，杯口不再外露，紧闭起来，与外界再无关联。

7，写出下面代码的执行结果：  

(function(){
    var val=1;
    var json={
        val:10,
        col:21,
        dbl:function(){
            val*=2
            console.log(this)
            console.log(val)
        }
    }
    json.dbl();
    console.log(json.val+val)
}())
//答：这是一个自调用函数，第一个val是局部变量，json对象也是一个局部变量，dbl方法中的val*=2是val=val*2的简写，由于是json调用了dbl方法所以this指向的是json对象 

8，把get-elmemt-by-id代码转化为驼峰命名法  

var str="get-element-by-id";
function stringToCamel(str){
      var temp=str.split("-");
      for(var i=1;i<temp.length;i++){
         temp[i]=temp[i][0].toUpperCase()+temp[i].slice(1);
      }
      return temp.join("");
}
console.log(stringToCamel(str))
//思路，将字符串使用split方法以-分割，然后把第一项之后的每一个的首字母转换为大写,slice() 方法可从已有的数组中返回选定的元素。 

9，substr substring slice 之间有什么区别？  

substring(1,5)**参数一开始的位置，参数二结束的位置，只能用于截取字符串* start,end
slice(1,5)**参数一开始的位置，参数二结束的位置，可以截取数组，可以传递负数，start,end
substr(1,5)**参数一开始的位置，参数二截取的长度，只能用于截取字符串，可以传负数* length 

10,冒泡排序  

var arr=[1,8,7,3,5,4,9,40]
for(var i=0;i<arr.length;i++){
    for(var a=i+1;a<arr.length;a++){
        if(arr[i]>arr[a]){
            [arr[i],arr[a]]=[arr[a],arr[i]]
        }
    }
}
console.log(arr)(注意a=i+1 不是a=a+1,使用了解构赋值的写法)  

11，用js实现数组反转  

方法一：
var arr = [1,2,3,3,4]
arr.reverse();
方法二：
var arr    = [1,2,3,3,4]
var newArr = Array()
for(var i = 0;i<arr.length;i++){
    newArr.unshift(arr[i])
}
console.log(newArr)
方法三：
a      = [1,2,3]
newarr = [...a].map(a.pop,a)
console.log(newarr)
//pop从后面删除元素，只能是一个，返回值是删除的元素

方法四：
var arr = new Array(1, 2, 3, 4, 5);
var res = new Array();
for (var i = arr.length-1; i >= 0; i--) {
    res.push(arr[i]);
}
arr = res;
console.log(arr);

方法五：
var a = new Array(1, 2, 3, 4, 5);
var b =new Array();
while(a.length){
    b.push(a.pop())
}
console.log(b);

12， 用es6一行代码实现数组去重  

var arr=[1,2,4,5,7,4,1,4,2,21,4]
   var set=[...new Set(arr)]//转换数组
   var set=Array.from(set)//非数组转换数组
   console.log(set)
   
  用es6的Set的唯一特性这玩意，实现去重，当然他生成的是为数组，所以要用Array.from 

其他方法

   var arr = [1, 2, 4, 5, 7, 4, 1, 4, 2, 21, 4]

    var newarr = Array()

    for (let i = 0; i < arr.length; i++) {

        if (newarr.indexOf(arr[i]) == -1) {

            newarr.push(arr[i])

        }

    }

    console.log(newarr);

13，字符串反转

方法一：
var str    = '12354'
var newstr = str.split('').reverse().join('')
console.log(newstr)
方法二：
var str = "abcdef" 
var i   = str.length; 
i=i-1; 
var newstr=''
for (var x = i; x >=0; x--) 
{ 
    newstr+=str.charAt(x); 
}
console.log(newstr)
方法三：
 var a   = [];
 var str = "feiesoft";
 var b   = str.split('');
 for(var i=0;i<str.length;i++){
      a.unshift(b[i]);
 }
 var newstr =  a.join("");

console.log(newstr)

14,typeof可以检测哪些数据类型  

number  Boolean  string  object  undefined  function 

15，检测是否是数组的方式？（三星）  

var arr=[1,2,4,5,7,4,1,4,2,21,4]
   //es5
   console.log(Array.isArray(arr))
   //原型式
   console.log(Object.prototype.toString.call(arr)=='[object Array]')
   //instanceof
   console.log(arr instanceof Array)
   //constructor
   console.log(arr.constructor === Array) 

16，typeof,Instanceof 和constructor 检测数据类型有什么区别  

用法不同，检测机制不同
typeof  一元运算符 返回一个表达式的数据类型的字符串，返回结果为js基本的数据类型，包括number,boolean,string,object,undefined,function.
语法：typeof(data) 或 typeof data

instanceof  二元运算符
返回一个布尔值，该值指示一个对象是否为特定类的一个实例。
语法： object instanceof class

constructor 属性,存在于Object.prototype的属性
返回对象的构造函数，
语法： object.constructor

 17，cookie sessionStorage localstorage 的区别？

cookie   存储在浏览器  可以设置存储时间 不设置的话关闭浏览器数据清除 存放数据大小 4k左右

sessionStorage 关闭浏览器数据清除 存放数据大小 5m或者更大

localstorage 关闭浏览器数据不清除   除非手动清除数据 存放数据大小 5m或者更大

18，函数节流(throttle)和函数去斗(debounce)  

防止用户多次点击或者下拉

(1) 浏览器滚动事件scroll
  (2)  鼠标的点击事件 mouseup, mousedown,mousemove
  (3)  键盘的keyup, keydown， input事件
  (4)  window的resize事件

以上四个场景中，事件都是连续触发的，如果也连续执行相应的回调函数，不但浪费资源，而且没有意义，还有可能导致浏览器或者服务器崩溃。

函数节流：
设定一个时间周期，周期性的执行一个函数；
函数去斗：
设定一个延迟时间，延迟时间到了再去执行函数，如果在延迟时间内重复调用则重新计算延迟时间 

代码：防抖---------------------------
    <script>
        var tims = ""
        function fn(){
            console.log('121223');
        }
        function dianji(){
            clearTimeout(tims)
            tims = setTimeout(()=>{
                this.fn()
            },1000)
        }
    </script>
    
    节流：--------------------------
        <script>
        var tims = false
        function fn(){
            console.log('121223');
        }
        function mob(){
           if(tims == true){
               return
           }
           tims = true
            setTimeout(()=>{
                this.fn()
                tims = false
            },2000)
        }
    </script>

19，跨域问题是怎样产生的？ 解决方案有哪些？

同源策略（协议名，域名，端口号（出于安全考虑））

Jsonp ，代理， cors，后端配置传 /api

1，20 ，融汇贯通，
2，数组去重，
3，实现防抖节流的代码案例

20， Jspon原理是什么  

jsonp开不是一种数据格式，通过动态创建script标签来读取其他域的动态资源

jsonp是用来解决跨域获取数据的一种解决方案， 具体是通过动态创建script标签，然后通过标签的src属性获取js文件中的is脚本，该脚本的内容是-一个函数调用，参数就是服务器返回的数据，为了处理这些返回的数据，需要事先在页面定义好回调函数，本质上使用

的并不是ajax 技术

21，从一个 url地址输入到页面呈现在用户面前 发什么了什么？  

DNS解析：将域名解析为IP地址
Tcp的三次连接：tcp的三次挥手{
    浏览器是否可以发送请求
    服务端浏览段可以发送请求
    浏览器端向服务器发送请求
}
发送HTTP请求，请求头
服务器处理请求返回HTTP报文，响应头
浏览器解析渲染页面
断开连接tcp四次挥手

三次握手：

    1，告诉服务端我要请求了，就问你允许不
    2，服务端收到访问响应一下说“可以”
    3，客服端说“那好我来了”
    
四次挥手：
    1，客户端说我不想和你合作了，想结束咱俩的关系
    2，服务端收到，表示说知道并且确认了，这个时候客户端就是等待状态离婚
    3，服务端，发送请求告诉客户端说完成财产分割，可以关闭了
    4，客户端收到，就给服务器说确认了没问题，然后就关了

 22，闭包有什么缺陷？

 滥用闭包会造成内存泄漏，因为闭包中引用的的包裹函数中定义的变量永远不会被释放，所以我们在必要的时候机试释放这个闭包函数（赋值为null）
注意：此说法不一定正确，因为 IE。IE 有 bug，IE 在我们使用完闭包之后，依然回收不了闭包里面引用的变量。
这是 IE 的问题，不是闭包的问题。参见司徒正美的这篇文章。
https://www.cnblogs.com/rubylouvre/p/3345294.html

 23，下面代码输出结果

var a='sdfd';
    function a(){
        console.log('sdfc')
    }
    a();
    
   // 报错func1不是一个函数：Uncaught TypeError: a is not a function
   
1)函数声明会置顶
2)变量声明也会置顶
3)函数声明比变量声明更置顶：(函数在变量上面)
4)变量和赋值语句一起书写，在js引擎解析时，会将其拆成声明和赋值2部分，声明置顶，赋值保留在原来位置
5)声明过的变量不会重复声明

------知道以上的规则,上面的代码等同于-----
var a=function (){
　　console.log(a);
}
var a=100;
a();
相当于给a重新赋值了，所以会报错。

24，JavaScript中的事件流模型  

冒泡事件流：
当触发一个节点的事件时，会从当前节点开始，依次触发其祖先节点的同类型事件，直到DOM根节点 。

捕获事件流：
当触发一个节点的事件时，会从DOM根节点开始，依次触发其祖先节点的同类型事件，直到当前节点自身 。

当使用addEventListener绑定事件，第三个参数设为true时表示事件捕获，除此之外的所有事件均为事件冒泡
例：（修改后面的true和false既可）
<div id="div1">
    111
    <div id="div2">
        222
        <div id="div3">
            333
        </div>
    </div>
</div>
<script>
div1.addEventListener("click",function(){
    console.log("div1 is 1 click");
},false);
div2.addEventListener("click",function(){
    console.log("div2 is 22click");
},false);
div3.addEventListener("click",function(){
    console.log("div3 is 333 click");
},false);
</script>

25， 什么是原型继承 写一个实例（三星）  

function Parent() {
  this.name   = 'parent';
  this.colors = ['black', 'yellow', 'red']
}
function Child() {
  this.type = 'child';
}
Parent.prototype.age = 12;
Parent.prototype.say = function(){
  console.log('hello');
}
Child.prototype = new Parent();
var q1 = new Child();
console.log(q1.name);//parent
console.log(q1.age); // 12
console.log(q1.say()); // hello undefined(因为方法没返回)) 

26，什么是构造函数继承（call或apply）  

function Parent() {
  this.name = 'parent';
  this.colors = ['black', 'yellow', 'red']
}
function Child() {
  Parent.call(this);
  this.type = 'child';
}
Parent.prototype.age = 12;
Parent.prototype.say = function(){
  console.log('hello');
}
var q1 = new Child();
console.log(q1.name);  // parent
console.log(q1.colors);// [ 'black', 'yellow', 'red' ]
console.log(q1);       //Child {name: "parent", colors: Array(3), type: "child"}
console.log(q1.age);   // undefined
console.log(q1.say()); // 报错  TypeError: q1.say is not a function 

27，如何阻止事件冒泡和默认事件  

e.stopPropagation()://标准浏览器
   event.cancelBubble=true;//ie9之前
阻止默认事件:
为了不让a点击之后跳转，我们就要给他的点击事件进行阻止
return false
e.preventDefault(); 

28，添加、删除、替换、插入到某个节点的方法（js、jq）  

 js：
Document.createELement('div'); //创建一个新的节点
appendChild()//添加
removeChild()//删除节点
insertBefore（插入节点，被插节点）//插入（前插后）
replaceChild（新节点,旧节点）//替换（前替换后）
jq：
append() （旧节点添加新节点后面）
appendTo() （新节点添加到旧节点后面）
prepend() （旧节点添加新节点的前面）
prependTo() （新节点添加到旧节点的前面）//添加
remove()（//清空）
empty()//删除
replaceWith（）//替换

29，JavaScript中的本地对象、内置对象和宿主对象（三星下）  

本地对象：
简单来说，本地对象就是 ECMA-262（js） 定义的类（引用类型）。它们包括：
Object, Function,Array,String,Boolean.Number,Date...等等

内置对象：
其中Global和Math这两个对象又被称为“内置对象”，这两个对象在脚本程序初始化时被创建，不必实例化这两个对象。
Global对象是ECMAScript中最特别的对象，因为实际上它根本不存在，但大家要清楚，在ECMAScript中，不存在独立的函数，所有函数都必须是某个对象的方法。类似于isNaN()、parseInt()和parseFloat()方法等

宿主对象：
浏览器对象有很多，如Window和Document等等。（所有 BOM 和 DOM 对象都是宿主对象。）

自定义对象
顾名思义，就是开发人员自己定义的对象。JS允许使用自定义对象，使JS应用及功能得到扩充

 30，window.onload和document .ready的区别

window.onload:
1》不仅要在结构和样式加载完，还要执行完所有的样式、图片这些资源文件，全部加载完才会触发window.onload事件
2》window.onload: 只执行一次

Document.ready：
1》内存中加载完成就触发速度快
2》Document.ready多 次使用

Document.ready原生中没有这个方法，jquery 中有$(document).ready(function)可以多次执行|

31，”==”和“===”的不同 a++和++a 有什么不同？  

：==是只比较值是否相等
   ===比较数据类型和值 
 a++ a先赋值，然后a自增1，最后返回赋值先进行表达式运算，再进行自增运算
 ++a 将A自增然后返回a 先进行自增运算，再进行表达式运算。 

32，输出今天的日期  

var myDate = new Date();
var time   = myDate.toLocaleDateString().split('/').join('-');
console.log(time); 

如果要输出年月日时分秒：
var myDate = new Date();
var time = myDate.toLocaleString().replace(/下午/, " ");

33，邮箱的正则验证  

//验证邮箱
var emailReg= /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/;
emailReg.test(str) 

 34,js解析url的get参数

www.baidu.com?name=1&age=2&like=3

console.log(window.location.href)//获取路径
console.log(window.location.search)//获取参数

 35打印结果

var a=10
var b=20
var c=30
++a;
a++
e=++a+(++b)+(c++)+a++
console.log(e)//77

36，打印结果

for(i=0,j=0;i<10,j<6;i++,j++){
    k=i+j
}
console.log(k)//10 

37，ajax 请求数据时get和post方式有什么区别

get请求会将参数跟在URL后进行传递，get方式传输的数据大小不能超过2KB

而POST请求则是作为HTTP消息的实体内容发送给Web服务器的，用户不见的。

get方式传输的数据大小不能超过2KB 而POST要大的多

GET 方式请求的数据会被浏览器缓存起来，因此有安全问题。

38，ajax请求时，如何解析json数据

var obj='{"name":"zhangsan","age":"19"}';
obj = JSON.parse(obj);
console.log(obj.name)//zhangsan 

39， typeof null 返回值是多少 为什么？

 答：object 因为null指向一个空对象 

40，new操作符具体干了什么

答：
①创建一-个空对象，并且this 变量引用该对象，同时还继承了该函数的原型。

②属性和方法被加入到this 引用的对象中。

③新创建的对象由this

41，不使用第三方框架 获取页面中所用的checkbox?

var inputs = document.getElementsByTagName('input');
var checkbox = [];
for(var i=0;i<inputs.length;i++){
    if(inputs[i].type=='checkbox'){
        checkbox.push(inputs[i])
    }
}
console.log(checkbox) 

42，form中的input可以设置为readonly和disable，请问2者有什么区别？

readonly不可编辑，但可以选择和复制；值可以传递到后台
disabled不能编辑，不能复制，不能选择；值不可以传递到后台 

43，简述ajax 流程

1)客户端产生js的事件
2)创建XMLHttpRequest对象
3)对XMLHttpRequest进行配置
4)通过AJAX引擎发送异步请求
5)服务器端接收请求并且处理请求，返回html或者xml内容
6)XML调用一个callback()处理响应回来的内容
7)页面局部刷新 

44，找出字符串中出现次数最多的字符：例如：‘aaaccvffdddssss’  

var str='asdfasdfasdfasd'
var obj = {}; // 先定义一个空对象,稍后使用.

for (var i = 0; i < str.length; i++) { //   循环字符串中每一项
    var k = str[i]; // 把每一项保存给变量 k (对这一步不理解可先熟悉 for循环机制);

  
    if (obj[k]) {

        obj[k]++;
    } else {
        obj[k] = 1;
    }
}

console.log(obj); // 输出{d: 1, j: 6, a: 5, o: 2, u: 2, …};

let num = 0;
let value = null;
for (var j in obj) {
    if (obj[j] > num) {
        num = obj[j];            // 这一步是找出出现最多的那个字母, 也就是最大的那个数
        value = j;
    }
}

console.log(value, num); // 输出 "h" 4
流程共分为两部, 第一步是先把每个字母出现的次数计算出来; 第二步是把出现最多的那个字母和次数找出来;

方法二：
        var maxNumber = function(digits) {
          const arr = digits.split(''); // 将字符串转成数组
          let hash = {}; // 定义hash用来计算
          for (let i = 0; i < arr.length; i++) {
            // 如果当前hash中没有该元素 数量为1 如果有 数量+=1
            hash[arr[i]] = !hash[arr[i]] ? 1 : (hash[arr[i]] += 1);
          }
          // 根据键值排序键名
          let keys = Object.keys(hash);
          keys.sort((a, b) => {
            return hash[b] - hash[a];
          });
          return `${keys[0]}出现次数最多，出现${hash[keys[0]]}次`;
        };
        console.log(maxNumber('hajjfhlhhffhhhh'));

 45，反转字符串abcdjjjf

var str="abcdef"
 console.log(str.split('').reverse().join('')) 

46，js 数组常用方法  

       1.pop（） 删除并返回数组的最后一个元素
       2.push()    表示向数组的末尾添加一个或多个元素
       3.shift()    表示删除并返回数组的第一个元素
       4.splice()   删除一个元素并且向删除的元素位置添加一个新元素
       5.unshift()  表明向数组的开头添加一个元素或多个元素并且返回新的长度
       6.sort()    表明对数组的元素进行排序，一般是升序排列
       7.reverse()   表示颠倒数组中元素的顺序
       8.toString()    表示把数组转化为字符串并返回结果
       9.slice()    表示从某个已有的数组返回选定的元素
       10.join()     把数组的所有元素放入一个字符串
       11.indexOf(el)   从头（序号0）开始查找元素 
       12.lastIndexOf(el)   从尾部（序号1）开始查找元素 

47，js常用的字符串方法  

toUpperCase` :把小写字母转成大写 
`toLowerCase` 把大写转小写 
`charAt` :通过索引获取字符 
`charCodeAt` :通过索引获取对应字符的Unicode编码； 
`substr` :截取 substr(m,n) 从索引m开始，截取n个字符； 
`substring`: substring(m,n)：从索引m开始，截取到索引n，不包含n; (不支持负数) 
`slice(m,n)`:substring; 从索引m开始，截取到索引n，不包含n (支持负数) 
`indexOf` :检测字符在字符串中第一次出现的索引位置； 
`lastIndexOf` :检测字符在字符串中最后一次出现的索引位置； 
`split`: 把字符串按照特定的字符分隔数组中的每一项； 
`replace`:替换;原有字符串不变；用新字符替换旧的字符 
`concat` :拼接 
`trim` :去空格 : 去除字符串中左右的空格； 

48,代码输出  

var a ='z'
var b ={
    name:'nihao'
}
function f1(ag1,ag2){
    // ag1 = a 值传递
    // ag2 = b 引用传递
    ag1='改变'
    ag2.name='sorry'
}
f1(a,b)
console.log(a,b)
// z ,sorry
1.值类型是传值的

2.对象和数组是传址的
如果你覆盖了这个对象，则不是传址了而是传值，对于的结果不会被重置，如果修改对象的一部分，则还是传址，结果会被重置

49，简述link和@import的区别？  

区别1: link 是HTML标签，除了加载CSS外，还可以定义RSS等其他事务; @import 属于CSS范畴，只能加载CSS。
区别2:link引用CSS时，在页面载入时同时加载;@import需要页面网页完全载入以后加载
区别3: link 是HTML标签，无兼容问题，@import 是在CSS2.1提出的，低版本的浏览器不支持。
区别4: link 支持使用Javascript 控制DOM去改变样式:而@import不支持。 

50，http状态码有哪些分别表示什么？  

200:请求已成功，请求所希望的响应头或数据体将随此响应返回。
302:请求的资源临时从不同的URI 响应请求。由于这样的重定向是临时的，客户端应当继
续向原有地址发送以后的请求。只有在Cache-Control或Expires中进行了指定的情况下，这
个响应才是可缓存的
304:: 如果客户端发送了一个带条件的GET请求且该请求已被允许，而文档的内容(自.上
次访问以来或者根据请求的条件)并没有改变，则服务器应当返回这个状态码。304响应禁
止包含消息体，因此始终以消息头后的第一一个空行结尾。
403:服务器已经理解请求，但是拒绝执行它。|
404:请求失败，请求所希望得到的资源未被在服务器上发现。
500:服务器遇到了一个未曾预料的状况，导致了它无法完成对请求的处理。一般来说，这
个问题都会在服务器端的源代码出现错误时出现。