JavaScript中必需把握的10个根基问题

JavaScript 是一种客户端编程说话。 环球超越90％的网站都在使用它，它是世界上最常用的编程说话之一。 因此，今天JavaScript栏目来计议 10 个有关 JavaScript 的常见问题。

1.怎样从数组中移除一个特定的项

思绪：第一，使用indexOf查寻要删除的数组元素的索引(index)，然后使用splice办法删除该索引所对应的项。

splice()是一个非纯函数，通过删除现有元素和/或增加新元从来更换数组的内容。

const array = [2, 5, 9]

const index = array.indexOf(5)
if (index > -1) {
  array.splice(index, 1)
}

console.log(array)
// [ 2, 9 ]复制代码

splice的第二个参数是要删除的元素数目。留意，splice会在恰当的位置修改数组，并返回一个包括已删除元素的新数组。

接着，我们可以来完美一下。下面有两个函数，第一个函数仅删除一个匹配项（即从[2,5,9,1,5,8,5]中删除第一个匹配项5），而第二个函数则删除所有匹配项：

// 仅删除第一个匹配项
function removeItemOnce (arr, value) {
  let index = arr.indexOf(value)
  if (index > -1) {
    arr.splice(index, 1)
  }
  return arr
}

// 删除所有匹配项
function removeItemAll (arr, value) {
  let i = 0
  while(i < arr.length) {
    if (arr[i] === value) {
      arr.splice(i, 1)
    } else {
      ++i
    }
  }
}复制代码

删除数组中索引i处的元素：

删除数组中索引i处的元素:

array.splice(i, 1)复制代码

假如你想从数组中删除值为number的每个元素，可以这样做：

for (let i = array.length - 1; i>=0; i--) {
  if (array[i] === number) {
    array.splice(i, 1)
  }
}复制代码

假如你只想使索引i处的元素不再存在，但又不想更换其他元素的索引：

delete array[i]复制代码

2. 怎样使用 jQuery 或纯 JS 将会员从一个页面重定向到另一个页面

jQuery 不是必需的，window.location.replace(…)最适合模拟 HTTP 重定向。window.location.replace(...)优于使用window.location.href，由于replace()不会将原始页面保存在会话历史记载中，这意味着会员将不会堕入永无停止回退按钮。

假如要模拟单击链接，可以使用location.href，假如要模拟HTTP重定向，请使用location.replace。

事例：

//模拟HTTP重定向
window.location.replace("http://stackoverflow.com")

// 模拟单击链接
window.location.href = "http://stackoverflow.com"复制代码

你还可以这样做：

$(location).attr('href', 'http://stackoverflow.com')复制代码

3.JavaScript 闭包是怎样工作的

闭包是一个函数和对该函数外部作用域的援用(词法环境)，词法环境是每个施行上下文（堆栈）的一部分，并且是标识符（即部分变量名称）和值之间的映射。

JavaScript 中的每个函数都保护对其外部词法环境的援用。此援用用于配置调取函数时创立的施行上下文。不管何时调取函数，该援用使函数内的代码能够查看在函数外声明的变量。

鄙人面的代码中，inner与调取foo时创立的施行上下文的词法环境一起构成一个闭包，并对外部潜藏了变量secret：

function foo() {
  const secret = Math.trunc(Math.random()*100)
  return function inner() {
    console.log(`The secret number is ${secret}.`)
  }
}
const f = foo() // secret 不克不及从foo 外部直接拜访
f() // 拜访 secret 的独一方法就是调取 f复制代码

换句话说，在JavaScript中，函数带有对私有状态的援用，只要它们(乃至在雷同的词法环境中声明的任何其他函数)可以拜访该私有状态。这个状态对函数的调取者是不成见的，这为数据潜藏和封装供给了一种优异的机制。

请记住，JavaScript中的函数可以像变量一样传递，这意味着这些功效和状态的对可以在程序中传递:相似于在c++中传递类的实例。

假如JavaScript没有闭包，则必需在函数之间显式传递更多状态，从而使参数列表更长，代码更冗余。

所以，假如你想让一个函数总是能够拜访私有状态，你可以使用一个闭包，我们经常想把状态和函数联络起来。例如，在Java或c++中，当你向类增加私有实例变量和办法时，这是将状态与功效关联起来。

在 C 说话和大多数其他编程说话中，函数返回后，由于堆栈被烧毁，所有的部分变量都不再可拜访。在JavaScript中，假如在另一个函数中声明一个函数，那么外部函数的当地变量在返回后依然可以拜访。这样，在上面的代码中，secret在从foo返回后依然对函数对象内部可用。

闭包在需要与函数关联的私有状态时非常有用。这是一个非常常见的场景，JavaScript直到2015年才有类语法，它依然没有私有字段语法，闭包知足了这一需求。

私有实例变量

鄙人面的事例中，函数 toString 潜藏了 Car 类的一些细节。

function Car(manufacturer, model, year, color) {
  return {
    toString() {
      return `${manufacturer} ${model} (${year}, ${color})`
    }
  }
}
const car = new Car('Aston Martin','V8 Vantage','2012','Quantum Silver')
console.log(car.toString())复制代码

函数式编程

鄙人面的代码中，函数inner潜藏了fn和args。

function curry(fn) {
  const args = []
  return function inner(arg) {
    if(args.length === fn.length) return fn(...args)
    args.push(arg)
    return inner
  }
}

function add(a, b) {
  return a + b
}

const curriedAdd = curry(add)
console.log(curriedAdd(2)(3)()) // 5复制代码

面向事件的编程

在以下代码中，函数onClick潜藏了变量BACKGROUND_COLOR。

const $ = document.querySelector.bind(document)
const BACKGROUND_COLOR = 'rgba(200,200,242,1)'

function onClick() {
  $('body').style.background = BACKGROUND_COLOR
}

$('button').addEventListener('click', onClick)复制代码

<button>Set background color</button>复制代码

模块化

鄙人面的示例中，所有实现细节都潜藏在一个马上施行的函数表达式中。函数tick和toString潜藏了私有状态和函数，它们需要完成本人的工作。闭包使我们能够模块化和封装我们的代码。

let namespace = {};

(function foo(n) {
  let numbers = []
  function format(n) {
    return Math.trunc(n)
  }
  function tick() {
    numbers.push(Math.random() * 100)
  }
  function toString() {
    return numbers.map(format)
  }
  n.counter = {
    tick,
    toString
  }
}(namespace))

const counter = namespace.counter
counter.tick()
counter.tick()
console.log(counter.toString())复制代码

事例 1：

此示例演示部分变量未在闭包中复制。 闭包保存对原始变量本身的援用。 好像即便外部函数退出后，堆栈仍在内存中保存。

function foo () {
  let x = 42
  let inner = function () {
    console.log(x)
  }
  x = x + 1
  return inner
}

let f = foo()
f()复制代码

事例 2：

鄙人面的代码中，三种办法log ，increment 和update 都在统一词法环境闭包中。

function createObject() {
  let x = 42;
  return {
    log() { console.log(x) },
    increment() { x++ },
    update(value) { x = value }
  }
}

const o = createObject()
o.increment()
o.log() // 43
o.update(5)
o.log() // 5
const p = createObject()
p.log() // 42复制代码

事例 3：

假如使用的变量是使用var声明的，需要留意的一点是，使用var声明的变量被晋升。 由于引入了let和const，这在现代JavaScript 中几乎没有问题。

鄙人面的代码中，每次轮回中，都会创立一个新的inner函数，变量i被覆盖，但是因var会让 i 晋升到函数的顶部，所以所有这些inner函数覆盖的都是统一个变量，这意味着i(3)的终究值被打印了三次。

function foo () {
  var result = []
  for (var i = 0; i < 3; i++) {
    result.push(function inner () {
      console.log(i)
    })
  }
  return result
}
const result = foo()

for(var i = 0; i < 3; i++) {
  result[i]()
}
// 3 3 3复制代码

最后一点：

• 每当在JavaScript中声明函数时，都会创立一个闭包。

• 从一个函数内部返回另一个函数是闭包的经典例子，由于外部函数内部的状态关于返回的内部函数是隐式可用的，即便外部函数已经完成施行。

• 只要在函数内使用eval()，就会使用一个闭包。eval的文本可以援用函数的部分变量，在非严厉模式下，乃至可以通过使用eval('var foo = ')创立新的部分变量。

• 当在函数内部使用new Function()(Function constructor)时，它不会覆盖其词法环境，而是覆盖全局上下文。新函数不克不及援用外部函数的部分变量。

• 在JavaScript中，闭包相似于在函数声明时保存对作用域的援用(而不是复制)，后者又保存对其外部作用域的援用，以此类推，不断到作用域链顶端的全局对象。

• 声明函数时创立一个闭包。 当调取函数时，此闭包用于配置施行上下文。

• 每次调取函数时都会创立一组新的部分变量。

JavaScript 中的每个函数都保护与其外部词法环境的链接。 词法环境是所有名称的映射（例如，变量，参数）及其范畴内的值。因此，只要看到function关键字，函数内部的代码就可以拜访在函数外部声明的变量。

function foo(x) {
  var tmp = 3;

  function bar(y) {
    console.log(x + y + (++tmp)); // 16
  }

  bar(10);
}

foo(2);复制代码

上面输出结果是16，参数x和变量tmp都存在于外部函数foo的词法环境中。函数bar及其与函数foo的词法环境的链接是一个闭包。

函数不必返回即可创立闭包。 仅仅凭借其声明，每个函数都会在其封闭的词法环境中关闭，从而构成一个闭包。

function foo(x) {
  var tmp = 3;

  return function (y) {
    console.log(x + y + (++tmp)); // 16
  }
}

var bar = foo(2);
bar(10); // 16
bar(10); // 17复制代码

上面还是打印16，由于bar内的代码依然可以援用参数x和变量tmp，即便它们不再直接的作用域内。

但是，由于tmp依然在bar的闭包内部彷徨，因此可以对其停止递增。 每次调取bar时，它将增添1。

闭包最简便的例子是这样的:

var a = 10;

function test() {
  console.log(a); // will output 10
  console.log(b); // will output 6
}
var b = 6;
test();复制代码

当调取一个JavaScript函数时，将创立一个新的施行上下文ec。连同函数参数和目标对象，这个施行上下文还接收到调取施行上下文的词法环境的链接，这意味着在外部词法环境中声明的变量(在上面的例子中，a和b)都可以从ec获得。

每个函数都会创立一个闭包，由于每个函数都有与其外部词法环境的链接。

留意，变量本身在闭包中是可见的，而不是副本。

4. use strict 在 JavaScript 中做了什么，背后的缘由是啥

援用一些有味的部分：

严厉模式是ECMAScript 5中的一个新特性，它同意我们将程序或函数放置在严厉的操纵上下文中。这种严厉的上下文会防止某些操纵被施行，并激发更多非常。

严厉模式在许多方面都有帮忙：

• 它捕捉了一些常见的编码破绽，并抛出非常。
• 当采取相对不平安的操纵(例如拜访全局对象)时，它可以防止错误或抛出错误。
• 它禁用令人困惑或思考不周密的特性。

别的，请留意，我信可以将“strict mode”利用于整个文件，也可以仅将其用于特定函数。

// Non-strict code...

(function(){
  "use strict";

  // Define your library strictly...
})();

// Non-strict code... 
复制代码

假如是在混合使用旧代码和新代码的状况，这大概会有所帮忙。它有点像在Perl中使用的“use strict”。通过检测更多大概致使破坏的东西，帮忙我们减少更多的错误。

此刻所有主流阅读器都支撑严厉模式。

在原生ECMAScript模块(带有import和export语句)和ES6类中，严厉模式始终是启用的，不克不及禁用。

5.怎样检查字符串可否包括子字符串？

ECMAScript 6 引入了string .prototype.include

const string = "foo";
const substring = "oo";

console.log(string.includes(substring));复制代码

不外，IE 不支撑 includes。在 CMAScript 5或更早的环境中，使用String.prototype.indexOf。假如寻不到子字符串，则返回-1:

var string = "foo";
var substring = "oo";

console.log(string.indexOf(substring) !== -1);复制代码

为了使其在旧的阅读器中运转，可以使用这种polyfill：

if (!String.prototype.includes) {
  String.prototype.includes = function(search, start) {
    'use strict';
    if (typeof start !== 'number') {
      start = 0;
    }

    if (start + search.length > this.length) {
      return false;
    } else {
      return this.indexOf(search, start) !== -1;
    }
  };
}复制代码

6. var functionName = function() {} 与 function functionName() {}

不一样之处在于functionOne是一个函数表达式，因此只在抵达这一行时才会定义，而functionTwo是一个函数声明，在它四周的函数或足本被施行(由于晋升)时就定义。

如，函数表达式

// TypeError: functionOne is not a function
functionOne();

var functionOne = function() {
  console.log("Hello!");
};复制代码

函数声明:

// "Hello!"
functionTwo();

function functionTwo() {
  console.log("Hello!");
}复制代码

过去，在不一样的阅读器之间，在块中定义的函数声明的处置是不一致的。严厉模式(在ES5中引入)解决了这个问题，它将函数声明的范畴限制在其封闭的块上。

'use strict';    
{ // note this block!
  function functionThree() {
    console.log("Hello!");
  }
}
functionThree(); // ReferenceError复制代码

function abc(){}也具有作用域-名称abc在碰到该定义的作用域中定义。 例：

function xyz(){
  function abc(){};
  // abc 在这里定义...
}
// ...不是在这里复制代码

假如想在所有阅读器上给函数起别号，可以这么做：

function abc(){};
var xyz = abc;复制代码

在本例中，xyz和abc都是统一个对象的别号

console.log(xyz === abc) // true复制代码

它的名称是主动分配的。但是当你定义它的时候

var abc = function(){};
console.log(abc.name); //  ""复制代码

它的name称为空，我们创立了一个匿名函数并将其分配给某个变量。使用组合样式的另一个很好的理由是使用简短的内部名称来援用本身，同时为外部会员供给一个长而不会冲突的名称：

// 假设 really.long.external.scoped 为 {}
really.long.external.scoped.name = function shortcut(n){
  // 它递归地调取本人:
  shortcut(n - 1);
  // ...
  // 让它本人作为回调传递：:
  someFunction(shortcut);
  // ...
}复制代码

在上面的例子中，我们可以对外部名称停止一样的操纵，但是这样做太笨拙了(并且速度更慢)。另一种援用本身的办法是arguments.callee，这种写法也相对较长，并且在严厉模式中不受支撑。

实际上，JavaScript看待这两个语句是不一样的。下面是一个函数声明：

function abc(){}复制代码

这里的abc可以定义在当前作用域的任何地方：

// 我们可以在这里调取
abc(); 

// 在这里定义
function abc(){}

// 也可以在这里调取 
abc(); 
复制代码

此外，尽管有 return 语句，也可以晋升：

// 我们可以在这里调取
abc(); 
return;
function abc(){}复制代码

下面是一个函数表达式:

var xyz = function(){};复制代码

这里的xyz是从赋值点开端定义的:

// 我们不成以在这里调取
xyz(); 

// 在这里定义 xyz
xyz = function(){}

// 我们可以在这里调取
xyz(); 
复制代码

函数声明与函数表达式之间存在差别的真正缘由。

var xyz = function abc(){};
console.log(xyz.name); // "abc"复制代码

就个人而言，我们更喜爱使用函数表达式声明，由于这样可以操纵可见性。当我们像这样定义函数时:

var abc = function(){};复制代码

我们知道，假如我们没有在作用域链的任何地方定义abc，那么我们是在全局作用域内定义的。即便在eval()内部使用，这品种型的定义也具有弹性。而定义:

function abc(){};复制代码

取决于上下文，并且大概让你推测它的实际定义位置，特殊是在eval()的状况下，—取决于阅读器。

7.怎样从 JavaScript 对象中删除属性？

我们可以这样删除对象的属性：

delete myObject.regex;
// 或者
delete myObject['regex'];
//  或者
var prop = "regex";
delete myObject[prop];复制代码

事例：

var myObject = {
    "ircEvent": "PRIVMSG",
    "method": "newURI",
    "regex": "^http://.*"
};
delete myObject.regex;

console.log(myObject);复制代码

JavaScript 中的对象可以看作键和值之间的映射。delete操纵符用于一次删除一个键(平常称为对象属性)。

var obj = {
  myProperty: 1    
}
console.log(obj.hasOwnProperty('myProperty')) // true
delete obj.myProperty
console.log(obj.hasOwnProperty('myProperty')) // false复制代码

delete 操纵符不是直接开释内存，它不一样于简便地将null或undefined值赋给属性，而是将属性本身从对象中删除。

留意，假如已删除属性的值是援用类型(对象)，而程序的另一部分依然持有对该对象的援用，那么该对象当然不会被垃圾收集，直到对它的所有援用都消逝。

delete只对其描写符标志为configurable的属性有效。

8. JS 的比力中应使用哪个等于运算符（== vs ===）？

严厉相等运算符(===)的行动与抽象相等运算符(==)雷同，除非不停止类型转换，并且类型必需雷同才能被认为是相等的。

==运算符会停止类型转换后比力相等性。 ===运算符不会停止转换，因此假如两个值的类型不一样，则===只会返回false。

JavaScript有两组相等运算符:===和!==，乃至它们的孪生兄弟==和!=。假如这两个操纵数具有雷同的类型和雷同的值，那么===的结果就是 true，而!==的结果就是 false。

下面是一些事例：

'' == '0'           // false
0 == ''             // true
0 == '0'            // true

false == 'false'    // false
false == '0'        // true

false == undefined  // false
false == null       // false
null == undefined   // true

' \t\r\n ' == 0     // true复制代码

上面有些看起来会挺困惑的，所以尽量还是使用严厉比力运算符(===)。关于援用类型，==和===操纵一致(非凡状况除外)。

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true复制代码

非凡状况是，当你将一个字符串字面量与一个字符串对象停止比力时，由于该对象的toString或valueOf办法，该对象的值与相字面量的值一样。

思考将字符串字面量与由String结构函数创立的字符串对象停止比力：

"abc" == new String("abc")    // true
"abc" === new String("abc")   // false复制代码

在这里，==操纵符检查两个对象的值并返回true，但是===看到它们不是统一类型并返回false。哪一个是准确的?这取决于你想要比力的是啥。

我们的倡议是完全绕开该问题，只是不要使用String结构函数来创立字符串对象。

使用==运算符（等于）

true == 1; //true, 由于 true 被转换为1，然后停止比力
"2" == 2;  //true, 由于 “2” 被转换成 2，然后停止比力复制代码

使用===操纵符

true === 1; //false
"2" === 2;  //false复制代码

9.在 JavaScript 中深拷贝一个对象的最有效办法是啥？

快速克隆，数据丧失– JSON.parse/stringify

假如您没有在对象中使用Date、函数、undefined、Infinity、RegExp、Map、Set、blob、、稀少数组、类型化数组或其他复杂类型，那么可以使用一行简便代码来深拷贝一个对象：

JSON.parse(JSON.stringify(object))复制代码

const a = {
  string: 'string',
  number: 123,
  bool: false,
  nul: null,
  date: new Date(), 
  undef: undefined,  // 丧失
  inf: Infinity,  // 被设定为 null
  re: /.*/,  // 丧失
}
console.log(a);
console.log(typeof a.date);  // object
const clone = JSON.parse(JSON.stringify(a));
console.log(clone);
/*
object
{
  string: 'string',
  number: 123,
  bool: false,
  nul: null,
  date: '2020-09-04T00:45:41.823Z',
  inf: null,
  re: {}
}

*/
console.log(typeof clone.date);  // string复制代码

使用库停止可靠的克隆

由于克隆对象不是一件简便的事情(复杂类型、轮回援用、函数等等)，大多数主要的库都供给了拷贝对象的函数。假如你已经在使用一个库，请检查它可否具有对象克隆功效。例如

• lodash – cloneDeep; 可以通过lodash.clonedeep模块独自导入，假如你尚未使用供给深拷贝功效的库，那么它大概是你的最好选中

• AngularJS – angular.copy

• jQuery – jQuery.extend(true, { }, oldObject); .clone()仅克隆DOM元素

ES6

ES6 供给了两种浅拷贝机制:Object.assign()和spread语法。它将所有可枚举的自有属性的值从一个对象复制到另一个对象。例如

var A1 = {a: "2"};
var A2 = Object.assign({}, A1);
var A3 = {...A1};  // Spread Syntax复制代码

在之前的测试中，速度是最主要的问题

JSON.parse(JSON.stringify(obj))复制代码

这是深拷贝对象的最慢办法，它比jQuery.extend慢 10-20%。

当deep标记设定为false（浅克隆）时，jQuery.extend非常快。 这是一个不错的选中，由于它包罗一些用于类型验证的额外逻辑，并且不会复制不决义的属性等，但这也会使你的速度变慢。

假如想拷贝的一个对象且你知道对象构造。那么，你可以写一个简便的for (var i in obj)轮回来克隆你的对象，同时检查hasOwnProperty，这将比jQuery快得多。

var clonedObject = {
  knownProp: obj.knownProp,
  ..
}复制代码

留意在 Date 对象JSON上使用JSON.parse(JSON.stringify(obj))办法。JSON.stringify(new Date())以ISO格局返回日期的字符串表示，JSON.parse()不会将其转换回Date对象。

10.怎样在另一个JavaScript文件中包括一个JavaScript文件？

旧版本的JavaScript没有import、include或require，因此针对这个问题开发了很多不一样的办法。

但是从2015年(ES6)开端，JavaScript已经有了ES6模块标准，可以在Node中导入模块。为了与旧版阅读器兼容，可以使用Webpack和Rollup之类的构建工具和/或Babel这样的编译工具。

ES6 Module

从v8.5开端，Node.js就支撑ECMAScript (ES6)模块，带有--experimental-modules 标记，并且至少Node.js v13.8.0没有这个标记。要启用ESM(相关于Node.js此前的commonjs风格的模块系统[CJS])，你可以在 package.json中使用“type”:“module”。或者为文件供给扩展名.mjs。(相似地，假如默许为ESM，则用 Node.js 之前的CJS模块编写的模块可以命名为.cjs。)

使用package.json：

{
    "type": "module"
}复制代码

在 module.js： 中

export function hello() {
  return "Hello";
}复制代码

main.js:

import { hello } from './module.js';
let val = hello();  // val is "Hello";复制代码

使用.mjs，会有对应的module.mjs：

export function hello() {
  return "Hello";
}复制代码

在main.mjs 中

import { hello } from './module.mjs';
let val = hello();  // val is "Hello";复制代码

自Safari 10.1，Chrome 61，Firefox 60 和 Edge 16 开端，阅读器就已经支撑直接加载ECMAScript模块（不需要像Webpack这样的工具）。无需使用Node.js的.mjs扩展名； 阅读器完全忽略模块/足本上的文件扩展名。

<script type="module">
  import { hello } from './hello.mjs'; // Or it could be simply `hello.js`
  hello('world');
</script>复制代码

// hello.mjs -- or it could be simply `hello.js`
export function hello(text) {
  const p = document.createElement('p');
  p.textContent = `Hello ${text}`;
  document.body.appendChild(p);
}复制代码

大家都说简历没项目写，我就帮大家寻了一个项目，还附赠【搭建教程】。

阅读器中的动态导入

动态导入同意足本按照需要加载其他足本

<script type="module">
  import('hello.mjs').then(module => {
      module.hello('world');
    });
</script>复制代码

Node.js require

在 Node.js 中用的较多还是 module.exports/require

// mymodule.js
module.exports = {
   hello: function() {
      return "Hello";
   }
}复制代码

// server.js const myModule = require('./mymodule'); let val = myModule.hello(); // val is "Hello"

动态加载文件

我们可以通过动态创立 script 来动态引入文件：

function dynamicallyLoadScript(url) {
    var script = document.createElement("script"); 

    document.head.appendChild(script); 
}复制代码

检测足本何时施行

此刻，有一个个大问题。上面这种动态加载都是异步施行的，这样可以提高网页的机能。 这意味着不克不及在动态加载下立刻使用该资源，由于它大概还在加载。

例如：my_lovely_script.js包括MySuperObject：

var js = document.createElement("script");

js.type = "text/javascript";
js.src = jsFilePath;

document.body.appendChild(js);

var s = new MySuperObject();

Error : MySuperObject is undefined复制代码

然后，按F5从新加载页面，大概就有效了。那么该如何办呢？

我们可以使用回调函数来解决些问题。

function loadScript(url, callback)
{
    var head = document.head;
    var script = document.createElement('script');
    script.type = 'text/javascript';
    script.src = url;

    script.onload = callback;

    head.appendChild(script);
}复制代码

然后编写在lambda函数中加载足本后要使用的代码

var myPrettyCode = function() {
   // Here, do whatever you want
};复制代码

然后，运转代码：

loadScript("my_lovely_script.js", myPrettyCode);复制代码

请留意，足本大概在加载DOM之后或此前施行，详细取决于阅读器乃至可否包罗行script.async = false;。

相关免费学习引荐：javascript（视频）

以上就是JavaScript中必需把握的10个根基问题的具体内容，更多请关注百分百源码网其它相关文章！