Conoscenze di base di JavaScript che devi imparare ogni giorno

Concetti di base　

JavaScript è un linguaggio interpretato, il browser agisce come interprete. Durante l'esecuzione di js, nell'ambito dello stesso contesto, viene prima interpretato e poi eseguito. Durante l'interpretazione, vengono compilati i variabili definiti con le parole chiave function e var, e poi eseguiti da sopra a sotto e assegnati ai variabili.　

Sensibile alle maiuscole e minuscole　

In ECMASCript, tutto (compresi le variabili, i nomi delle funzioni e gli operatori) è sensibile alle maiuscole e minuscole.　

1. Variabile　

Le variabili vengono impostate nella memoria la prima volta che vengono utilizzate, rendendole facili da riferire nel script successivo. Prima di utilizzare una variabile, è necessario dichiararla. Puoi utilizzare la parola chiave var per dichiarare variabili.

var count, amount, level; // Variabili dichiarate con una singola parola chiave var.　

Nomina delle variabili　

Il nome delle variabili include variabili globali, variabili locali, variabili di classe, parametri delle funzioni, ecc., e appartengono a questa categoria.　

Il nome delle variabili deve essere composto da un prefisso di tipo + parole significative, utilizzando il metodo di nomi a camelCase per aumentare la leggibilità delle variabili e delle funzioni. Ad esempio: sUserName, nCount.
Norme di prefisso:
Ogni variabile locale deve avere un prefisso di tipo, che può essere classificato in:
s: rappresenta la stringa. Ad esempio: sName, sHtml;
n: rappresenta il numero. Ad esempio: nPage, nTotal;
b: rappresenta il logico. Ad esempio: bChecked, bHasLogin;
a：表示数组。例如：aList，aGroup；
r：表示正则表达式。例如：rDomain，rEmail；
f：表示函数。例如：fGetHtml，fInit；
o：表示以上未涉及到的其他对象，例如：oButton，oDate；
g：表示全局变量，例如：gUserName，gLoginTime；

JScript 是一种区分大小写的语言。创建合法的变量名称应遵循如下规则：　

注意第一个字符不能是数字。　

后面可以跟任意字母或数字以及下划线，但不能是空格 变量名称一定不能是 保留字。

javascript是一种弱类型语言，JavaScript 会忽略多余的空格。您可以向脚本添加空格，来提高其可读性。　

var是javascript的保留字，表明接下来是变量说明，变量名是用户自定义的标识符，变量之间用逗号分开。　

如果声明了一个变量但没有对其赋值，该变量存在，其值为Jscript 值 undefined。

强制类型转换　

在 Jscript 中，可以对不同类型的值执行运算，不必担心 JScript 解释器产生异常。相反，JScript 解释器自动将数据类型之一改变（强制转换）为另一种数据类型，然后执行运算。例如：

　运算　　　　　　　　　　　　　　　　　　　　　　　　　　　　 结果

Aggiunta di numeri e stringhe Forza la conversione di numeri in stringhe.
Aggiunta di valori booleani e stringhe Forza la conversione di valori booleani in stringhe.
Aggiunta di numeri e valori booleani Forza la conversione di valori booleani in numerici.

Per convertire esplicitamente una stringa in un intero, usa il metodo parseInt. Per convertire esplicitamente una stringa in un numero, usa il metodo parseFloat.　

Vita utile delle variabili JavaScript: quando dichiari una variabile all'interno di una funzione, puoi accedere a quella variabile solo all'interno della funzione. Quando esci dalla funzione, quella variabile viene annullata. Questo tipo di variabile si chiama variabile locale. Puoi usare lo stesso nome della variabile locale in diverse funzioni, perché solo la funzione che ha dichiarato la variabile può riconoscere ciascuna variabile.　

Se dichiari una variabile al di fuori della funzione, tutti i funzioni sulla pagina possono accedere a quella variabile. La vita utile di queste variabili inizia dopo la loro dichiarazione e termina quando la pagina viene chiusa.　

mind map delle variabili js

　

tipi di dati di 2.js　

jscript ha tre -> tipi di dati principali, due -> tipi di dati composti e due -> tipi di dati speciali.　

tipi di dati principali (basici)
stringa
numerico
booleano

tipi di dati composti (riferimento)
　oggetto
Array

Tipi di dati speciali
Null

Undefined

Tipo di dati stringa: il tipo di dati stringa viene utilizzato per rappresentare il testo in JScript. In js, anche se le virgolette doppi (" ") e le virgolette singole (') possono rappresentare stringhe e non hanno quasi differenze, si considera migliore utilizzare solo virgolette doppie (" ") per rappresentare stringhe.　

Un valore di stringa è una serie di zero o più caratteri Unicode (lettere, numeri e simboli) consecutivi.　

Cos'è Unicode?　

Unicode fornisce un valore numerico unico per ogni carattere, indipendentemente dalla piattaforma, dal programma o dal linguaggio. Lo sviluppo di Unicode è finalizzato a fornire una codifica unificata per la gestione di tutti i caratteri esistenti nel mondo.　

Tipo di dati numerico　

Dobbiamo capire un punto, JScript rappresenta tutti i numeri come valori a virgola mobile internamente, quindi in Jscript non c'è differenza tra interi e valori a virgola mobile.　

Tipo di dati Booleano　

Booleano (logico) può avere solo due valori: true o false.　

Array e oggetti in JavaScript　

Dettagli nel mio articolo->riassunto di studio JavaScript - parte array e oggetti　

Tipo di dati Null: è possibile pulire il contenuto di una variabile assegnando null a una variabile.　

In Jscript, l'operatore typeof rapporterà il valore null come tipo Object, non come tipo null.

 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
  <meta http-equiv="Content-Type" content="text/html;charset=UTF-8" />
 <title></title>
 <script type="text/javascript"> 
   alert(typeof null);
 </script>
</head>
<body>
</body>
</html> 

Null viene utilizzato per rappresentare un oggetto non esistente, spesso utilizzato per rappresentare una funzione che tenta di restituire un oggetto inesistente.　

Tipo di dati Undefined:　

In queste circostanze verrà restituito il valore undefined:
Proprietà dell'oggetto non esistente,
Dichiarazione di variabile mai assegnata.

La differenza tra null e undefined

alert(typeof undefined); //output "undefined" 
alert(typeof null); //output "object" 
alert(null == undefined); //output "true" 

ECMAScript considera undefined come derivato da null, quindi li definisce uguali.

alert(null === undefined); //output "false" 
alert(typeof null == typeof undefined); //output "false" 

Il tipo di null e undefined è diverso, quindi l'output è "false". Mentre === rappresenta l'uguaglianza assoluta, qui null === undefined outputta "false"　

Inoltre, qui viene presentato un tipo di dati molto importante - i tipi di dati di riferimento　

Tipi di dati di riferimento　

I tipi di dati di riferimento in JavaScript sono oggetti memorizzati nella memoria heap, JavaScript non consente di accedere direttamente agli spazi di memoria heap e di operare sulla memoria heap, ma può solo operare sugli indirizzi di riferimento degli oggetti nella memoria stack. Pertanto, i dati di tipo di riferimento vengono memorizzati negli indirizzi di riferimento degli oggetti nella memoria stack. Attraverso questo indirizzo di riferimento è possibile trovare rapidamente l'oggetto memorizzato nella memoria heap.　

Ora eseguiamo una dimostrazione del processo di assegnazione dei tipi di dati di riferimento

　

Naturalmente, aggiungere l'attributo name a obj2 significa aggiungere l'attributo name all'oggetto nella memoria heap, mentre obj2 e obj1 memorizzano solo gli indirizzi di riferimento degli oggetti nella memoria stack, anche se è stata fatta una copia, ma l'oggetto puntato è lo stesso. Pertanto, la modifica di obj2 ha causato la modifica di obj1.　

I valori di tipo di base sono quelli memorizzati nei segmenti di dati semplici nel stack, ovvero questo valore viene memorizzato completamente in una posizione della memoria.
　I valori di tipo di riferimento sono quelli memorizzati nella memoria heap degli oggetti, ovvero ciò che viene effettivamente memorizzato nelle variabili è un puntatore, che punta a un altro indirizzo di memoria nella memoria, dove viene memorizzato l'oggetto.　

In breve, la memoria heap contiene i valori di riferimento, mentre la memoria stack contiene valori di tipo fisso.

　

In ECMAScript, le variabili possono avere due tipi di valori, ovvero i valori primitivi e i valori di riferimento.　

I valori di tipo primitivo vengono memorizzati in un segmento di dati semplice nel stack (stack), ovvero i loro valori vengono memorizzati direttamente nella posizione di accesso delle variabili. I valori di riferimento vengono memorizzati in oggetti nel heap (heap), ovvero il valore memorizzato nella variabile è un puntatore (point), che punta all'indirizzo di memoria in cui viene memorizzato l'oggetto.

 <script type="text/javascript">
var box = new Object(); //Creazione di un tipo di riferimento
var box = "lee";  //Il valore di tipo base è una stringa
box.age = 23;  //L'attributo aggiunto al valore di tipo base è molto strano, perché solo gli oggetti possono aggiungere attributi.
alert(box.age); //不是引用类型，无法输出；
</script> 

3.JScript 的运算符　

优先级：指运算符的运算顺序，通俗的说就是先计算哪一部分。
结合性：同一优先级运算符的计算顺序，通俗的说就是从哪个方向算起，是左到右还是右到左。　

数据类型转换和基本包装类型　

String() 转换为字符串类型
Number() 转换为数字类型
Boolean() 转换为布尔类型　

parseInt：将字符串转换为整数。从字符串的开头开始解析，在第一个非整数的位置停止解析，并返回前面读到所有的整数。如果字符串不是以整数开头的，将返回NaN。如：parseInt（“150 hi”）返回的值是：150，parseInt(“hi”)返回的值是：NaN。
　parseFloat：将字符串转换为浮点数。 从字符串的开头开始解析，在第一个非整数的位置停止解析，并返回前面读到所有的整数。如果字符串不是以整数开头的，将返回NaN。如：parseFloat("15.5 hi") 返回的值是：15.5，parseFloat("hi 15.5")返回的值是：NaN。

　eval：将字符串作为javascript表达式进行计算，并返回执行结果，如果没有结果则返回undefined。
基本包装类型　

每当读取一个基本类型值的时候，后台就会创建一个对应的基本包装类型的对象，从而能调用一些方法来操作这些数据。基本包装类型包括Boolean、Number和String

 var box = 'trigkit4'; //字面量
box.name = 'mike';  //无效属性
box.age = function () { //无效方法}
  return 22;
;
//new运算符写法
var box = new String('trigkit4');//new 运算符
box.name = 'mike';  //有效属性
box.age = function () { //有效方法}
  return 22;
; 

String类型包含了三个属性和大量的可用内置方法
　属性　　　描述
length: 返回字符串的字符长度
Constructor: 返回创建String对象的函数
prototype: 通过添加属性和方法扩展字符串定义

4.js controllo del flusso　

Per le istruzioni di controllo del flusso JavaScript, parlerò solo di alcune che sono più difficili da comprendere. Non esporrò altre. Di seguito è allegata una mappa mentale.　

1.L'istruzione for...in esegue uno o più statement per ogni proprietà di un oggetto o per ogni elemento di un array.
　for (variable in [oggetto | array])
statements

Parametro:　
variable: obbligatoria. Una variabile, che può essere una proprietà di un oggetto o un elemento di un array.
　object, array: opzionale. L'oggetto o l'array su cui eseguire la scansione.
　statement: opzionale. Un o più statement devono essere eseguiti per ogni proprietà di un oggetto o per ogni elemento di un array. Può essere un statement complesso.　

Sebbene le istruzioni di controllo delle condizioni (come if) richiedano l'uso di un blocco di codice (inizializzato con la parentesi graffata aperta {} e chiusa }) solo quando eseguiti più istruzioni, è una buona pratica utilizzare sempre un blocco di codice.

 if(args)
  alert(args); // facile da sbagliare
if(args){
  alert(args); // raccomandato
}

　5.js funzione　

Una funzione è un blocco di codice riutilizzabile che viene eseguito quando viene invocata o attivato da un evento.　

Jscript supporta due tipi di funzioni: una è la funzione interna del linguaggio, l'altra è quella creata da sé.
Le funzioni JavaScript possono avere pochi argomenti (ma i parentesi tonde non possono essere omessi) e possono passare argomenti alla funzione per utilizzarli.　

Per ulteriori informazioni sui funzioni, visitate il mio altro articolo: grande sommario di studio JavaScript (quarto capitolo) - parte funzione function　

Composizione dell'oggetto
Metodo - Funzione: processo, dinamico
Proprietà - Variabile: stato, statico

Infine, ecco una mappa mentale riassuntiva creata da un collega:

Questo è tutto il contenuto dell'articolo, spero che sia utile per il vostro studio. Spero anche che continuiate a supportare il tutorial URLAJO.