Ici, j'ai compilé et résumé certaines fonctions JavaScript de base pour vous, qui sont toutes relativement courantes et pratiques. L'organiser aidera également tout le monde à mieux comprendre JavaScript.
La copie de code est la suivante:
<script type = "text / javascript">
/ * Créer des fonctions et des fonctions littérales * /
/ *
fonction add () {
alerte ("fonction créée avec succès")
};
var testFunction = function () {
alert ("Ceci est une fonction anonyme");
};
ajouter(); // appelle la fonction
TestFunction (); // appelle la fonction littérale
* /
/ *
var testoBj = new object (); // Créer un objet
testoBj.run = function () {// Créez une méthode pour l'objet
alert ("Ceci est la méthode à l'intérieur de l'objet");
};
testoBj.run (); // appelle la méthode de l'objet
* /
/ * Créer un objet de fonction * /
/ *
fonction Ball () {
}
ball.name1 = "test"; // Créer des attributs pour les objets de fonction
alerte (ball.name1); // Propriétés de la fonction d'accès
alerte (type de balle)
* /
/ * Référence à la fonction * /
/ *
fonction myFunction (message) {
alerte (message);
}
var ptr = myfunction; // transmette la référence de la fonction à la variable
PTR ("test"); // Fonction des appels variables
* /
/ * Passez une référence à la fonction à l'objet * /
/ *
Fonction saitname (name1) {
alert (name1);
}
var obj1 = nouveau objet ();
var obj2 = nouveau objet ();
var obj3 = nouveau objet ();
obj1.sayMyName = SayName; // la méthode pour former l'objet en passant la référence à la variable utilisée pour transmettre la référence à l'objet.
obj2.SayMyName = SayName;
obj3.SayMyName = SayName;
obj1.saymyName ("Zhang San") // La méthode d'appel de l'objet
obj2.SayMyName ("li si");
Obj3.SayMyName ("Wang Wu")
* /
/ *
fonction add () {
}
Add.Message = "Chaiyesong"
var ptr1 = add;
var ptr2 = add;
alerte (ptr1.Message);
alerte (ptr2.Message)
Add.Message = "123";
alerte (ptr1.Message)
alerte (ptr2.Message)
* /
/ * Points de référence à une autre variable * /
/ *
fonction add () {
alerte ("un");
}
var ptr = add;
ptr = function () {// Créer une autre fonction appelée myFonctionptr au lieu de le modifier
alerte ("ptr")
}
add = function () {// la référence pointe vers une autre fonction, modifiant la référence de la fonction
alerte ("deux")
}
ajouter()
ptr ()
* /
/ * Créer un objet de fonction * /
/ *
Fonction Ball (message) {
alerte (message)
}
var ball0 = new ball ("test")
ball0.name1 = "ball-0"
alerte (ball0.name1)
Fonction Ball (message) {
alerte (message)
}
var ball0 = nouvel objet ()
Ball0.Construct = Ball; // pointer la référence au constructeur d'un objet
Ball0.Construct ("CeshiqueshiShi") // Exécutez cette fonction par le constructeur de cet objet
ball0.name1 = "Tesing"
alerte (ball0.name1)
fonction test () {
}
alert (test.prototype) // partager des propriétés
* /
/ * Ajouter des attributs partagés * /
/ *
FOIS FOIS (NAEM1, Color1) {
this.name1 = naem1
this.color1 = color1
}
Fish.prototype.livesin = "water" // ajouter un attribut partagé
Fish.prototype.price = 20
Var Fish1 = Nouveau poisson ("Mackrel", "Gray")
var poisson2 = nouveau poisson ("poisson rouge", "orange");
var poisson3 = nouveau poisson ("saumon", "blanc");
pour (var i = 1; i <= 3; i ++)
{
Var Fish = Eval ("Fish" + I); // Je viens juste du pointeur de ce poisson
alerte (fish.name1 + "," + fish.color1 + "," + fish.livesin + "," + fish.price);
}
* /
/ *
Employé de fonction (nom, salaire)
{
this.name = name;
this.salary = salaire;
}
Employee.prototype.getsalary = fonction getAlaryFunction ()
{
Renvoyez ce.Salaire;
}
Employee.prototype.addsalary = fonction addSalaryFunction (ajout)
{
this.salary = this.salary + ajout;
}
var boss1 = nouvel employé ("Joan", 200000);
var boss2 = nouvel employé ("kim", 100000);
var boss3 = nouvel employé ("sam", 150000);
alert (boss1.getsalary ()); // Sortie 200000
alert (boss2.getSalary ()); // Sortie 100000
alert (boss3.getSalary ()); // Sortie 150000
* /
/ * Fonction anonyme * /
/ *
(fonction (x, y) {
alerte (x + y)
}) (2,3) // La capacité de cette fonction à s'exécuter
* /
/ * Exécuter et appeler la fonction * /
/ *
var f1 = fonction () {
Renvoie des "tests"
}
alerte (f1 ())
* /
/ * Donnez le résultat de l'auto-exécution à la variable * /
/ *
var f2 = fonction () {
retourner "ok"
} ()
alerte (F2)
* /
// (
// fonction(){
// alerte ("FA")
//} ()
//)
/ *
Box de fonction () {
var user = 'tt'
return function () {
RETOUR UTILISATEUR;
}
}
alert (box () ()) // appelle la fonction embarquée
* /
// var b = box ()
// alerte (b ())
/ * Ajouter automatiquement via la fonction de fermeture * /
/ *
Box de fonction () {
Var Age = 100
return function () {// Cette méthode est réellement appelée, ce qui implémente l'heure où réside les données en mémoire
Âge ++
âge de retour;
}
}
var b = box ()
alerte (b ())
alerte (b ())
alerte (b ())
* /
/ * Démarrer la version * /
/ *
Box de fonction () {
var arr = [] // Déclarer un tableau
pour (var i = 0; i <5; i ++) {
arr [i] = fonction () {// La fonction est affectée à chaque élément via une boucle
retour i;
}
}
retour arr; // retourne un tableau
}
var b = box () // attribue le tableau renvoyé à b
Document.Writeln ("La longueur du tableau est:" + B.Length + "<Br />") // Renvoie la longueur du tableau
pour (var i = 0; i <b.length; i ++) {
document.writeln ("La valeur renvoyée par la fonction anonyme est:" + b [i] () + "<br />") // La valeur de chaque élément de cette fonction est 5, car la valeur du dernier élément est 5
};
* /
/ * Version améliorée * /
/ *
fonction box1 () {
var arr1 = [];
pour (var i = 0; i <5; i ++) {
Arr1 [i] = (fonction (num) {// auto-exécution, en attribuant le résultat de la fonction auto-exécution à chaque élément
retour num;
})(je); // et passer les paramètres
}
retour arr1;
}
var b1 = box1 (); // retourne le tableau
pour (var i = 0; i <b1.length; i ++) {
Document.Writeln ("Le résultat de sortie amélioré est:")
document.writeln (b1 [i] + "<r />"); // Le retour retourné est un tableau, il suffit de l'imprimer directement
}
* /
// version bêta
/ *
var testarr = [];
pour (var i = 0; i <5; i ++) {
testarr [i] = fonction () {
retour i;
}
};
document.writeln ("La longueur de la carte de test est:" + testarr.length + "<br>")
pour (var i = 0; i <testarr.length; i ++) {
document.writeln ("version bêta" + (i + 1) + "time" + testarr [i] + "<br />")
};
var aa = fonction () {
retour 3
}
Document.Writeln ("Résultat du test bêta" + aa)
* /
/ * Version améliorée 3 * /
/ *
fonction box3 () {
var arr3 = [];
pour (var i = 0; i <5; i ++) {
arr3 [i] = (fonction (num) {
return function () {
retour num;
}
}) (i); // Le résultat de l'auto-exécution est attribué à chaque élément. Une fois l'exécution terminée, le résultat de son exécution est attribué à chaque élément.
}
retour arr3;
}
var b3 = box3 ();
pour (var i = 0; i <b3.length; i ++) {
document.writeln (b3 [i] () + "<br />");
}
* /
/ * JS Fonction Tutorial Adresse: http://www.cnblogs.com/ttcc/p/3763437.html*/
/ * L'objet spécifié dans cette fermeture est la fenêtre * /
/ *
var user = 'the window00';
var obj = {
Utilisateur: «The Window001»,
getUserFunction: function () {
return function () {
Renvoyez ce.User;
}
}
}
Document.Writeln ("Renvoie l'objet spécifié par ce" + obj.getUserFunction () () ())
* /
// Box de fonction (count1) {
// var i = 12;
// pour (var i = 0; i <count1; i ++) {
// document.writeln (i);
//}
//}
// var i = 10
// boîte (2)
/ * Une fois la fermeture exécutée, les données de mémoire seront effacées immédiatement * /
/ *
Box de fonction (count) {
(fonction () {
pour (var i = 0; i <count; i ++) {
}
}) ();
document.writeln (i); // une erreur est signalée, incapable d'accéder
}
Encadré (2);
* /
/ * Accès aux attributs de confidentialité par la fermeture * /
/ *
Box de fonction () {
Var âge = 100; // Variable privée
fonction run () {// Fonction privée
retourner 'courir ...';
}
this.get = function () {// Méthode de privilège public extérieur
Return Age + run ();
};
}
var box = new Box ();
alert (box.get ());
fonction de fonction (valeur) {
var user = valeur; // Cette phrase peut être omise
this.getUser = function () {
RETOUR UTILISATEUR;
};
this.setUser = fonction (valeur) {
user = valeur;
};
}
* /
/ * Mode singleton * /
/ *
var box = function () {
var user = 'tt'; // Variable privée
fonction run () {// Fonction privée
retourner 'courir ...';
}
retour {
publicgo: function () {// Méthode privée d'interface publique externe
return user + run ();
}
};
} ();
alert (box.publicgo ());
* /
/ * Mode singleton * /
/ *
Function Desk () {
// définir une fonction
}
var box = function () {
var user = 'tt'; // Variable privée
fonction run () {// Fonction privée
retourner 'courir ...';
}
var Desk = new Desk (); // Instancier un objet personnalisé
Desk.PublicGo = function () {
return user + run (); // Définir les méthodes pour les fonctions personnalisées
};
Bureau de retour;
} ();
alert (box.publicgo ());
* /
</cript>
Ce qui précède est la fonction JavaScript de base compilée par moi. Amis, veuillez l'étudier attentivement et j'espère que vous l'aimez.